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/accessibility-manager/accessibility-manager.h>
 442
 443 #include <dali-toolkit/devel-api/builder/builder.h>
 444
 445 #include <dali-toolkit/devel-api/focus-manager/keyinput-focus-manager.h>
 446 #include <dali-toolkit/devel-api/focus-manager/keyboard-focus-manager-devel.h>
 447
 448 #include <dali-toolkit/devel-api/controls/control-devel.h>
 449 #include <dali-toolkit/devel-api/controls/popup/popup.h>
 450 #include <dali-toolkit/devel-api/controls/gaussian-blur-view/gaussian-blur-view.h>
 451 #include <dali-toolkit/devel-api/controls/page-turn-view/page-factory.h>
 452 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-view.h>
 453 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-landscape-view.h>
 454 #include <dali-toolkit/devel-api/controls/page-turn-view/page-turn-portrait-view.h>
 455 #include <dali-toolkit/devel-api/controls/buttons/toggle-button.h>
 456 #include <dali-toolkit/devel-api/controls/alignment/alignment.h>
 457 #include <dali-toolkit/devel-api/controls/scroll-bar/scroll-bar.h>
 458 #include <dali-toolkit/devel-api/controls/table-view/table-view.h>
 459
 460 #include <dali-toolkit/devel-api/visual-factory/visual-base.h>
 461 #include <dali-toolkit/devel-api/visual-factory/visual-factory.h>
 462 #include <dali-toolkit/devel-api/visual-factory/transition-data.h>
 463
 464 #include <dali-toolkit/public-api/visuals/visual-properties.h>
 465 #include <dali-toolkit/public-api/visuals/text-visual-properties.h>
 466 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 467
 468 #include <dali-toolkit/devel-api/controls/tooltip/tooltip-properties.h>
 469 #include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 470 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
 471
 472 #include <dali-toolkit/public-api/controls/scrollable/item-view/item-view-declarations.h>
 473
 474 #include <dali/devel-api/adaptor-framework/pixel-buffer.h>
 475 #include <dali/devel-api/adaptor-framework/image-loading.h>
 476
 477 #include <dali/public-api/events/mouse-button.h>
 478
 479 #include <dali-toolkit/devel-api/controls/web-view/web-view.h>
 480 #include "web-view-signal-converter.h"
 481
 482 #include <dali/integration-api/debug.h>
 483
 484 #include <dali-toolkit/devel-api/controls/video-view/video-view-devel.h>
 485
 486 #include <dali/devel-api/adaptor-framework/native-image-source-devel.h>
 487
 488 #include <dali-toolkit/devel-api/text/rendering-backend.h>
 489
 490 // add here SWIG version check
 491
 492 #if defined(_MSC_VER)         // Microsoft Visual C++ 6.0
 493 // disable Swig-dependent warnings
 494
 495 // 'identifier1' has C-linkage specified,
 496 // but returns UDT 'identifier2' which is incompatible with C
 497 #pragma warning(disable: 4190)
 498
 499 // 'int' : forcing value to bool 'true' or 'false' (performance warning)
 500 #pragma warning(disable: 4800)
 501
 502 // debug info too long etc etc
 503 #pragma warning(disable: 4786)
 504 #endif
 505
 506
 507 #include <stdexcept>
 508
 509
 510 #include <string>
 511
 512
 513 #include <vector>
 514 #include <algorithm>
 515 #include <stdexcept>
 516
 517
 518 #include <map>
 519 #include <algorithm>
 520 #include <stdexcept>
 521
 522
 523 #include <utility>
 524
 525
 526 typedef float floatp;
 527
 528 SWIGINTERN floatp *new_floatp(){
 529   return new float();
 530 }
 531 SWIGINTERN void delete_floatp(floatp *self){
 532   if (self) delete self;
 533 }
 534 SWIGINTERN void floatp_assign(floatp *self,float value){
 535   *self = value;
 536 }
 537 SWIGINTERN float floatp_value(floatp *self){
 538   return *self;
 539 }
 540 SWIGINTERN float *floatp_cast(floatp *self){
 541   return self;
 542 }
 543 SWIGINTERN floatp *floatp_frompointer(float *t){
 544   return (floatp *) t;
 545 }
 546
 547 typedef int intp;
 548
 549 SWIGINTERN intp *new_intp(){
 550   return new int();
 551 }
 552 SWIGINTERN void delete_intp(intp *self){
 553   if (self) delete self;
 554 }
 555 SWIGINTERN void intp_assign(intp *self,int value){
 556   *self = value;
 557 }
 558 SWIGINTERN int intp_value(intp *self){
 559   return *self;
 560 }
 561 SWIGINTERN int *intp_cast(intp *self){
 562   return self;
 563 }
 564 SWIGINTERN intp *intp_frompointer(int *t){
 565   return (intp *) t;
 566 }
 567
 568 typedef double doublep;
 569
 570 SWIGINTERN doublep *new_doublep(){
 571   return new double();
 572 }
 573 SWIGINTERN void delete_doublep(doublep *self){
 574   if (self) delete self;
 575 }
 576 SWIGINTERN void doublep_assign(doublep *self,double value){
 577   *self = value;
 578 }
 579 SWIGINTERN double doublep_value(doublep *self){
 580   return *self;
 581 }
 582 SWIGINTERN double *doublep_cast(doublep *self){
 583   return self;
 584 }
 585 SWIGINTERN doublep *doublep_frompointer(double *t){
 586   return (doublep *) t;
 587 }
 588
 589 typedef unsigned int uintp;
 590
 591 SWIGINTERN uintp *new_uintp(){
 592   return new unsigned int();
 593 }
 594 SWIGINTERN void delete_uintp(uintp *self){
 595   if (self) delete self;
 596 }
 597 SWIGINTERN void uintp_assign(uintp *self,unsigned int value){
 598   *self = value;
 599 }
 600 SWIGINTERN unsigned int uintp_value(uintp *self){
 601   return *self;
 602 }
 603 SWIGINTERN unsigned int *uintp_cast(uintp *self){
 604   return self;
 605 }
 606 SWIGINTERN uintp *uintp_frompointer(unsigned int *t){
 607   return (uintp *) t;
 608 }
 609
 610 typedef unsigned short ushortp;
 611
 612 SWIGINTERN ushortp *new_ushortp(){
 613   return new unsigned short();
 614 }
 615 SWIGINTERN void delete_ushortp(ushortp *self){
 616   if (self) delete self;
 617 }
 618 SWIGINTERN void ushortp_assign(ushortp *self,unsigned short value){
 619   *self = value;
 620 }
 621 SWIGINTERN unsigned short ushortp_value(ushortp *self){
 622   return *self;
 623 }
 624 SWIGINTERN unsigned short *ushortp_cast(ushortp *self){
 625   return self;
 626 }
 627 SWIGINTERN ushortp *ushortp_frompointer(unsigned short *t){
 628   return (ushortp *) t;
 629 }
 630
 631 unsigned int int_to_uint(int x) {
 632    return (unsigned int) x;
 633 }
 634
 635
 636 using namespace Dali;
 637 using namespace Dali::Toolkit;
 638
 639 SWIGINTERN bool Dali_BaseHandle_HasBody(Dali::BaseHandle const *self)
 640 {
 641   bool result = false;
 642   try
 643   {
 644     // C++ code. DALi uses Handle <-> Body design pattern.
 645     // This function checks the Handle to see if it has a body attached ( possible to have empty handles).
 646     // Handles in DALi can be converted into a boolean type
 647     // to check if the handle has a valid body attached to it.
 648     // Internally checking *self will  checks IntrusivePtr<Dali::RefObject> mObjectHandle in BaseHandle;
 649     if( *self )
 650     {
 651       result = true;
 652     }
 653     else
 654     {
 655       result = false;
 656     }
 657   }
 658   catch (std::out_of_range& e)
 659   {
 660     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 661     return 0;
 662   }
 663   catch (std::exception& e)
 664   {
 665     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 666     return 0;
 667   }
 668   catch (DaliException e)
 669   {
 670     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 671     return 0;
 672   }
 673   catch (...)
 674   {
 675     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 676     return 0;
 677   }
 678   return result;
 679 }
 680
 681 SWIGINTERN bool Dali_BaseHandle_IsEqual(Dali::BaseHandle const *self,Dali::BaseHandle const &rhs)
 682 {
 683   bool result = false;
 684   try
 685   {
 686     // C++ code. Check if two handles reference the same implemtion
 687     if( *self == rhs)
 688     {
 689       result = true;
 690     }
 691     else
 692     {
 693       result = false;
 694     }
 695   }
 696   catch (std::out_of_range& e)
 697   {
 698     SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what()));
 699     return 0;
 700   }
 701   catch (std::exception& e)
 702   {
 703     SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what()));
 704     return 0;
 705   }
 706   catch (DaliException e)
 707   {
 708     SWIG_CSharpException(SWIG_UnknownError, e.condition);
 709     return 0;
 710   }
 711   catch (...)
 712   {
 713     SWIG_CSharpException(SWIG_UnknownError, "unknown error");
 714     return 0;
 715   }
 716   return result;
 717 }
 718
 719
 720 SWIGINTERN void Dali_TypeRegistration_RegisterControl(std::string const &controlName,Dali::CSharpTypeInfo::CreateFunction createFunc){
 721      Dali::CSharpTypeRegistry::RegisterType( controlName, typeid( Dali::Toolkit::Control), createFunc );
 722    }
 723 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){
 724      Dali::CSharpTypeRegistry::RegisterProperty( controlName, propertyName, index, type, setFunc, getFunc );
 725    }
 726 SWIGINTERN std::vector< Dali::TouchPoint > *new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(int capacity){
 727         std::vector< Dali::TouchPoint >* pv = 0;
 728         if (capacity >= 0) {
 729           pv = new std::vector< Dali::TouchPoint >();
 730           pv->reserve(capacity);
 731        } else {
 732           throw std::out_of_range("capacity");
 733        }
 734        return pv;
 735       }
 736 SWIGINTERN Dali::TouchPoint std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(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 Dali::TouchPoint const &std_vector_Sl_Dali_TouchPoint_Sg__getitem(std::vector< Dali::TouchPoint > *self,int index){
 743         if (index>=0 && index<(int)self->size())
 744           return (*self)[index];
 745         else
 746           throw std::out_of_range("index");
 747       }
 748 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__setitem(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &val){
 749         if (index>=0 && index<(int)self->size())
 750           (*self)[index] = val;
 751         else
 752           throw std::out_of_range("index");
 753       }
 754 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__AddRange(std::vector< Dali::TouchPoint > *self,std::vector< Dali::TouchPoint > const &values){
 755         self->insert(self->end(), values.begin(), values.end());
 756       }
 757 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__GetRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 758         if (index < 0)
 759           throw std::out_of_range("index");
 760         if (count < 0)
 761           throw std::out_of_range("count");
 762         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 763           throw std::invalid_argument("invalid range");
 764         return new std::vector< Dali::TouchPoint >(self->begin()+index, self->begin()+index+count);
 765       }
 766 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Insert(std::vector< Dali::TouchPoint > *self,int index,Dali::TouchPoint const &x){
 767         if (index>=0 && index<(int)self->size()+1)
 768           self->insert(self->begin()+index, x);
 769         else
 770           throw std::out_of_range("index");
 771       }
 772 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 773         if (index>=0 && index<(int)self->size()+1)
 774           self->insert(self->begin()+index, values.begin(), values.end());
 775         else
 776           throw std::out_of_range("index");
 777       }
 778 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(std::vector< Dali::TouchPoint > *self,int index){
 779         if (index>=0 && index<(int)self->size())
 780           self->erase(self->begin() + index);
 781         else
 782           throw std::out_of_range("index");
 783       }
 784 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(std::vector< Dali::TouchPoint > *self,int index,int count){
 785         if (index < 0)
 786           throw std::out_of_range("index");
 787         if (count < 0)
 788           throw std::out_of_range("count");
 789         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 790           throw std::invalid_argument("invalid range");
 791         self->erase(self->begin()+index, self->begin()+index+count);
 792       }
 793 SWIGINTERN std::vector< Dali::TouchPoint > *std_vector_Sl_Dali_TouchPoint_Sg__Repeat(Dali::TouchPoint const &value,int count){
 794         if (count < 0)
 795           throw std::out_of_range("count");
 796         return new std::vector< Dali::TouchPoint >(count, value);
 797       }
 798 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(std::vector< Dali::TouchPoint > *self){
 799         std::reverse(self->begin(), self->end());
 800       }
 801 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(std::vector< Dali::TouchPoint > *self,int index,int count){
 802         if (index < 0)
 803           throw std::out_of_range("index");
 804         if (count < 0)
 805           throw std::out_of_range("count");
 806         if (index >= (int)self->size()+1 || index+count > (int)self->size())
 807           throw std::invalid_argument("invalid range");
 808         std::reverse(self->begin()+index, self->begin()+index+count);
 809       }
 810 SWIGINTERN void std_vector_Sl_Dali_TouchPoint_Sg__SetRange(std::vector< Dali::TouchPoint > *self,int index,std::vector< Dali::TouchPoint > const &values){
 811         if (index < 0)
 812           throw std::out_of_range("index");
 813         if (index+values.size() > self->size())
 814           throw std::out_of_range("index");
 815         std::copy(values.begin(), values.end(), self->begin()+index);
 816       }
 817 SWIGINTERN bool Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty(Dali::Signal< void (float) > const *self){
 818          return self->Empty();
 819       }
 820 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount(Dali::Signal< void (float) > const *self){
 821         return self->GetConnectionCount();
 822       }
 823 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(Dali::Signal< void (float) > *self,void (*func)(float)){
 824           self->Connect( func );
 825       }
 826 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(Dali::Signal< void (float) > *self,void (*func)(float)){
 827           self->Disconnect( func );
 828       }
 829 SWIGINTERN void Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(Dali::Signal< void (float) > *self,float arg){
 830           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 831 /*@SWIG@*/ self->Emit( arg );
 832       }
 833 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty(Dali::Signal< void (Dali::BaseHandle) > const *self){
 834          return self->Empty();
 835       }
 836 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::BaseHandle) > const *self){
 837         return self->GetConnectionCount();
 838       }
 839 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 840           self->Connect( func );
 841       }
 842 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(Dali::Signal< void (Dali::BaseHandle) > *self,void (*func)(Dali::BaseHandle)){
 843           self->Disconnect( func );
 844       }
 845 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(Dali::Signal< void (Dali::BaseHandle) > *self,Dali::BaseHandle arg){
 846           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 847 /*@SWIG@*/ self->Emit( arg );
 848       }
 849 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty(Dali::Signal< void (Dali::RefObject const *) > const *self){
 850          return self->Empty();
 851       }
 852 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){
 853         return self->GetConnectionCount();
 854       }
 855 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 *)){
 856           self->Connect( func );
 857       }
 858 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 *)){
 859           self->Disconnect( func );
 860       }
 861 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){
 862           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 863 /*@SWIG@*/ self->Emit( arg );
 864       }
 865 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 866          return self->Empty();
 867       }
 868 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::PropertyNotification &) > const *self){
 869         return self->GetConnectionCount();
 870       }
 871 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 872           self->Connect( func );
 873       }
 874 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(Dali::Signal< void (Dali::PropertyNotification &) > *self,void (*func)(Dali::PropertyNotification &)){
 875           self->Disconnect( func );
 876       }
 877 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(Dali::Signal< void (Dali::PropertyNotification &) > *self,Dali::PropertyNotification &arg){
 878           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 879 /*@SWIG@*/ self->Emit( arg );
 880       }
 881 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){
 882          return self->Empty();
 883       }
 884 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){
 885         return self->GetConnectionCount();
 886       }
 887 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 &)){
 888         self->Connect( func );
 889       }
 890 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 &)){
 891         self->Disconnect( func );
 892       }
 893 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){
 894         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 895 /*@SWIG@*/ self->Emit( arg1, arg2 );
 896       }
 897 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){
 898          return self->Empty();
 899       }
 900 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){
 901         return self->GetConnectionCount();
 902       }
 903 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 &)){
 904         self->Connect( func );
 905       }
 906 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 &)){
 907         self->Disconnect( func );
 908       }
 909 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){
 910         return self->Emit( arg1, arg2 );
 911       }
 912 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){
 913          return self->Empty();
 914       }
 915 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){
 916         return self->GetConnectionCount();
 917       }
 918 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 &)){
 919         self->Connect( func );
 920       }
 921 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 &)){
 922         self->Disconnect( func );
 923       }
 924 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){
 925         return self->Emit( arg1, arg2 );
 926       }
 927 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){
 928          return self->Empty();
 929       }
 930 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){
 931         return self->GetConnectionCount();
 932       }
 933 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 &)){
 934         self->Connect( func );
 935       }
 936 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 &)){
 937         self->Disconnect( func );
 938       }
 939 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){
 940         return self->Emit( arg1, arg2 );
 941       }
 942 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor) > const *self){
 943          return self->Empty();
 944       }
 945 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor) > const *self){
 946         return self->GetConnectionCount();
 947       }
 948 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 949           self->Connect( func );
 950       }
 951 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(Dali::Signal< void (Dali::Actor) > *self,void (*func)(Dali::Actor)){
 952           self->Disconnect( func );
 953       }
 954 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(Dali::Signal< void (Dali::Actor) > *self,Dali::Actor arg){
 955           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 956 /*@SWIG@*/ self->Emit( arg );
 957       }
 958 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::KeyEvent const &) > const *self){
 959          return self->Empty();
 960       }
 961 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){
 962         return self->GetConnectionCount();
 963       }
 964 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 &)){
 965           self->Connect( func );
 966       }
 967 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 &)){
 968           self->Disconnect( func );
 969       }
 970 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){
 971           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 972 /*@SWIG@*/ self->Emit( arg );
 973       }
 974 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::TouchData const &) > const *self){
 975          return self->Empty();
 976       }
 977 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){
 978         return self->GetConnectionCount();
 979       }
 980 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 &)){
 981           self->Connect( func );
 982       }
 983 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 &)){
 984           self->Disconnect( func );
 985       }
 986 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){
 987           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
 988 /*@SWIG@*/ self->Emit( arg );
 989       }
 990 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::WheelEvent const &) > const *self){
 991          return self->Empty();
 992       }
 993 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){
 994         return self->GetConnectionCount();
 995       }
 996 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 &)){
 997           self->Connect( func );
 998       }
 999 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 &)){
1000           self->Disconnect( func );
1001       }
1002 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){
1003           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1004 /*@SWIG@*/ self->Emit( arg );
1005       }
1006 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){
1007          return self->Empty();
1008       }
1009 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){
1010         return self->GetConnectionCount();
1011       }
1012 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 &)){
1013         self->Connect( func );
1014       }
1015 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 &)){
1016         self->Disconnect( func );
1017       }
1018 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){
1019         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1020 /*@SWIG@*/ self->Emit( arg1, arg2 );
1021       }
1022 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){
1023          return self->Empty();
1024       }
1025 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){
1026         return self->GetConnectionCount();
1027       }
1028 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 &)){
1029         self->Connect( func );
1030       }
1031 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 &)){
1032         self->Disconnect( func );
1033       }
1034 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){
1035         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1036 /*@SWIG@*/ self->Emit( arg1, arg2 );
1037       }
1038 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){
1039          return self->Empty();
1040       }
1041 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){
1042         return self->GetConnectionCount();
1043       }
1044 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 &)){
1045         self->Connect( func );
1046       }
1047 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 &)){
1048         self->Disconnect( func );
1049       }
1050 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){
1051         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1052 /*@SWIG@*/ self->Emit( arg1, arg2 );
1053       }
1054 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){
1055          return self->Empty();
1056       }
1057 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){
1058         return self->GetConnectionCount();
1059       }
1060 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)){
1061           return self->Connect( func );
1062       }
1063 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)){
1064           self->Disconnect( func );
1065       }
1066 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){
1067           self->Emit( arg1, arg3 );
1068       }
1069 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){
1070          return self->Empty();
1071       }
1072 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){
1073         return self->GetConnectionCount();
1074       }
1075 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)){
1076           return self->Connect( func );
1077       }
1078 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)){
1079           self->Disconnect( func );
1080       }
1081 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){
1082           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1083 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1084       }
1085
1086 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Empty(Dali::Signal< bool () > const *self){
1087          return self->Empty();
1088       }
1089 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount(Dali::Signal< bool () > const *self){
1090         return self->GetConnectionCount();
1091       }
1092 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(Dali::Signal< bool () > *self,bool (*func)()){
1093           self->Connect( func );
1094       }
1095 SWIGINTERN void Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(Dali::Signal< bool () > *self,bool (*func)()){
1096           self->Disconnect( func );
1097       }
1098 SWIGINTERN bool Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(Dali::Signal< bool () > *self){
1099           return self->Emit();
1100       }
1101
1102 SWIGINTERN std::vector< unsigned int > *new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(int capacity){
1103         std::vector< unsigned int >* pv = 0;
1104         if (capacity >= 0) {
1105           pv = new std::vector< unsigned int >();
1106           pv->reserve(capacity);
1107        } else {
1108           throw std::out_of_range("capacity");
1109        }
1110        return pv;
1111       }
1112 SWIGINTERN unsigned int std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(std::vector< unsigned int > *self,int index){
1113         if (index>=0 && index<(int)self->size())
1114           return (*self)[index];
1115         else
1116           throw std::out_of_range("index");
1117       }
1118 SWIGINTERN unsigned int const &std_vector_Sl_unsigned_SS_int_Sg__getitem(std::vector< unsigned int > *self,int index){
1119         if (index>=0 && index<(int)self->size())
1120           return (*self)[index];
1121         else
1122           throw std::out_of_range("index");
1123       }
1124 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__setitem(std::vector< unsigned int > *self,int index,unsigned int const &val){
1125         if (index>=0 && index<(int)self->size())
1126           (*self)[index] = val;
1127         else
1128           throw std::out_of_range("index");
1129       }
1130 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__AddRange(std::vector< unsigned int > *self,std::vector< unsigned int > const &values){
1131         self->insert(self->end(), values.begin(), values.end());
1132       }
1133 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__GetRange(std::vector< unsigned int > *self,int index,int count){
1134         if (index < 0)
1135           throw std::out_of_range("index");
1136         if (count < 0)
1137           throw std::out_of_range("count");
1138         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1139           throw std::invalid_argument("invalid range");
1140         return new std::vector< unsigned int >(self->begin()+index, self->begin()+index+count);
1141       }
1142 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Insert(std::vector< unsigned int > *self,int index,unsigned int const &x){
1143         if (index>=0 && index<(int)self->size()+1)
1144           self->insert(self->begin()+index, x);
1145         else
1146           throw std::out_of_range("index");
1147       }
1148 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__InsertRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1149         if (index>=0 && index<(int)self->size()+1)
1150           self->insert(self->begin()+index, values.begin(), values.end());
1151         else
1152           throw std::out_of_range("index");
1153       }
1154 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(std::vector< unsigned int > *self,int index){
1155         if (index>=0 && index<(int)self->size())
1156           self->erase(self->begin() + index);
1157         else
1158           throw std::out_of_range("index");
1159       }
1160 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(std::vector< unsigned int > *self,int index,int count){
1161         if (index < 0)
1162           throw std::out_of_range("index");
1163         if (count < 0)
1164           throw std::out_of_range("count");
1165         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1166           throw std::invalid_argument("invalid range");
1167         self->erase(self->begin()+index, self->begin()+index+count);
1168       }
1169 SWIGINTERN std::vector< unsigned int > *std_vector_Sl_unsigned_SS_int_Sg__Repeat(unsigned int const &value,int count){
1170         if (count < 0)
1171           throw std::out_of_range("count");
1172         return new std::vector< unsigned int >(count, value);
1173       }
1174 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(std::vector< unsigned int > *self){
1175         std::reverse(self->begin(), self->end());
1176       }
1177 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(std::vector< unsigned int > *self,int index,int count){
1178         if (index < 0)
1179           throw std::out_of_range("index");
1180         if (count < 0)
1181           throw std::out_of_range("count");
1182         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1183           throw std::invalid_argument("invalid range");
1184         std::reverse(self->begin()+index, self->begin()+index+count);
1185       }
1186 SWIGINTERN void std_vector_Sl_unsigned_SS_int_Sg__SetRange(std::vector< unsigned int > *self,int index,std::vector< unsigned int > const &values){
1187         if (index < 0)
1188           throw std::out_of_range("index");
1189         if (index+values.size() > self->size())
1190           throw std::out_of_range("index");
1191         std::copy(values.begin(), values.end(), self->begin()+index);
1192       }
1193 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Contains(std::vector< unsigned int > *self,unsigned int const &value){
1194         return std::find(self->begin(), self->end(), value) != self->end();
1195       }
1196 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__IndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1197         int index = -1;
1198         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1199         if (it != self->end())
1200           index = (int)(it - self->begin());
1201         return index;
1202       }
1203 SWIGINTERN int std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(std::vector< unsigned int > *self,unsigned int const &value){
1204         int index = -1;
1205         std::vector< unsigned int >::reverse_iterator rit = std::find(self->rbegin(), self->rend(), value);
1206         if (rit != self->rend())
1207           index = (int)(self->rend() - 1 - rit);
1208         return index;
1209       }
1210 SWIGINTERN bool std_vector_Sl_unsigned_SS_int_Sg__Remove(std::vector< unsigned int > *self,unsigned int const &value){
1211         std::vector< unsigned int >::iterator it = std::find(self->begin(), self->end(), value);
1212         if (it != self->end()) {
1213           self->erase(it);
1214           return true;
1215         }
1216         return false;
1217       }
1218 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){
1219         std::vector< std::pair< unsigned int,Dali::Actor > >* pv = 0;
1220         if (capacity >= 0) {
1221           pv = new std::vector< std::pair< unsigned int,Dali::Actor > >();
1222           pv->reserve(capacity);
1223        } else {
1224           throw std::out_of_range("capacity");
1225        }
1226        return pv;
1227       }
1228 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){
1229         if (index>=0 && index<(int)self->size())
1230           return (*self)[index];
1231         else
1232           throw std::out_of_range("index");
1233       }
1234 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){
1235         if (index>=0 && index<(int)self->size())
1236           return (*self)[index];
1237         else
1238           throw std::out_of_range("index");
1239       }
1240 SWIGINTERN void std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__setitem(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,std::pair< unsigned int,Dali::Actor > const &val){
1241         if (index>=0 && index<(int)self->size())
1242           (*self)[index] = val;
1243         else
1244           throw std::out_of_range("index");
1245       }
1246 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){
1247         self->insert(self->end(), values.begin(), values.end());
1248       }
1249 SWIGINTERN std::vector< std::pair< unsigned int,Dali::Actor > > *std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__GetRange(std::vector< std::pair< unsigned int,Dali::Actor > > *self,int index,int count){
1250         if (index < 0)
1251           throw std::out_of_range("index");
1252         if (count < 0)
1253           throw std::out_of_range("count");
1254         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1255           throw std::invalid_argument("invalid range");
1256         return new std::vector< std::pair< unsigned int,Dali::Actor > >(self->begin()+index, self->begin()+index+count);
1257       }
1258 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){
1259         if (index>=0 && index<(int)self->size()+1)
1260           self->insert(self->begin()+index, x);
1261         else
1262           throw std::out_of_range("index");
1263       }
1264 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){
1265         if (index>=0 && index<(int)self->size()+1)
1266           self->insert(self->begin()+index, values.begin(), values.end());
1267         else
1268           throw std::out_of_range("index");
1269       }
1270 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){
1271         if (index>=0 && index<(int)self->size())
1272           self->erase(self->begin() + index);
1273         else
1274           throw std::out_of_range("index");
1275       }
1276 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){
1277         if (index < 0)
1278           throw std::out_of_range("index");
1279         if (count < 0)
1280           throw std::out_of_range("count");
1281         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1282           throw std::invalid_argument("invalid range");
1283         self->erase(self->begin()+index, self->begin()+index+count);
1284       }
1285 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){
1286         if (count < 0)
1287           throw std::out_of_range("count");
1288         return new std::vector< std::pair< unsigned int,Dali::Actor > >(count, value);
1289       }
1290 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){
1291         std::reverse(self->begin(), self->end());
1292       }
1293 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){
1294         if (index < 0)
1295           throw std::out_of_range("index");
1296         if (count < 0)
1297           throw std::out_of_range("count");
1298         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1299           throw std::invalid_argument("invalid range");
1300         std::reverse(self->begin()+index, self->begin()+index+count);
1301       }
1302 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){
1303         if (index < 0)
1304           throw std::out_of_range("index");
1305         if (index+values.size() > self->size())
1306           throw std::out_of_range("index");
1307         std::copy(values.begin(), values.end(), self->begin()+index);
1308       }
1309 SWIGINTERN std::vector< Dali::Actor > *new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(int capacity){
1310         std::vector< Dali::Actor >* pv = 0;
1311         if (capacity >= 0) {
1312           pv = new std::vector< Dali::Actor >();
1313           pv->reserve(capacity);
1314        } else {
1315           throw std::out_of_range("capacity");
1316        }
1317        return pv;
1318       }
1319 SWIGINTERN Dali::Actor std_vector_Sl_Dali_Actor_Sg__getitemcopy(std::vector< Dali::Actor > *self,int index){
1320         if (index>=0 && index<(int)self->size())
1321           return (*self)[index];
1322         else
1323           throw std::out_of_range("index");
1324       }
1325 SWIGINTERN Dali::Actor const &std_vector_Sl_Dali_Actor_Sg__getitem(std::vector< Dali::Actor > *self,int index){
1326         if (index>=0 && index<(int)self->size())
1327           return (*self)[index];
1328         else
1329           throw std::out_of_range("index");
1330       }
1331 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__setitem(std::vector< Dali::Actor > *self,int index,Dali::Actor const &val){
1332         if (index>=0 && index<(int)self->size())
1333           (*self)[index] = val;
1334         else
1335           throw std::out_of_range("index");
1336       }
1337 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__AddRange(std::vector< Dali::Actor > *self,std::vector< Dali::Actor > const &values){
1338         self->insert(self->end(), values.begin(), values.end());
1339       }
1340 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__GetRange(std::vector< Dali::Actor > *self,int index,int count){
1341         if (index < 0)
1342           throw std::out_of_range("index");
1343         if (count < 0)
1344           throw std::out_of_range("count");
1345         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1346           throw std::invalid_argument("invalid range");
1347         return new std::vector< Dali::Actor >(self->begin()+index, self->begin()+index+count);
1348       }
1349 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Insert(std::vector< Dali::Actor > *self,int index,Dali::Actor const &x){
1350         if (index>=0 && index<(int)self->size()+1)
1351           self->insert(self->begin()+index, x);
1352         else
1353           throw std::out_of_range("index");
1354       }
1355 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__InsertRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1356         if (index>=0 && index<(int)self->size()+1)
1357           self->insert(self->begin()+index, values.begin(), values.end());
1358         else
1359           throw std::out_of_range("index");
1360       }
1361 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveAt(std::vector< Dali::Actor > *self,int index){
1362         if (index>=0 && index<(int)self->size())
1363           self->erase(self->begin() + index);
1364         else
1365           throw std::out_of_range("index");
1366       }
1367 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__RemoveRange(std::vector< Dali::Actor > *self,int index,int count){
1368         if (index < 0)
1369           throw std::out_of_range("index");
1370         if (count < 0)
1371           throw std::out_of_range("count");
1372         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1373           throw std::invalid_argument("invalid range");
1374         self->erase(self->begin()+index, self->begin()+index+count);
1375       }
1376 SWIGINTERN std::vector< Dali::Actor > *std_vector_Sl_Dali_Actor_Sg__Repeat(Dali::Actor const &value,int count){
1377         if (count < 0)
1378           throw std::out_of_range("count");
1379         return new std::vector< Dali::Actor >(count, value);
1380       }
1381 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(std::vector< Dali::Actor > *self){
1382         std::reverse(self->begin(), self->end());
1383       }
1384 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(std::vector< Dali::Actor > *self,int index,int count){
1385         if (index < 0)
1386           throw std::out_of_range("index");
1387         if (count < 0)
1388           throw std::out_of_range("count");
1389         if (index >= (int)self->size()+1 || index+count > (int)self->size())
1390           throw std::invalid_argument("invalid range");
1391         std::reverse(self->begin()+index, self->begin()+index+count);
1392       }
1393 SWIGINTERN void std_vector_Sl_Dali_Actor_Sg__SetRange(std::vector< Dali::Actor > *self,int index,std::vector< Dali::Actor > const &values){
1394         if (index < 0)
1395           throw std::out_of_range("index");
1396         if (index+values.size() > self->size())
1397           throw std::out_of_range("index");
1398         std::copy(values.begin(), values.end(), self->begin()+index);
1399       }
1400 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1401          return self->Empty();
1402       }
1403 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *self){
1404         return self->GetConnectionCount();
1405       }
1406 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 &)){
1407           self->Connect( func );
1408       }
1409 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 &)){
1410           self->Disconnect( func );
1411       }
1412 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){
1413           return self->Emit( arg );
1414       }
1415 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){
1416          return self->Empty();
1417       }
1418 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){
1419         return self->GetConnectionCount();
1420       }
1421 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)){
1422         self->Connect( func );
1423       }
1424 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)){
1425         self->Disconnect( func );
1426       }
1427 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){
1428         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1429 /*@SWIG@*/ self->Emit( arg1, arg2 );
1430       }
1431 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,Dali::Actor) > const *self){
1432          return self->Empty();
1433       }
1434 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){
1435         return self->GetConnectionCount();
1436       }
1437 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)){
1438         self->Connect( func );
1439       }
1440 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)){
1441         self->Disconnect( func );
1442       }
1443 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){
1444         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1445 /*@SWIG@*/ self->Emit( arg1, arg2 );
1446       }
1447 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty(Dali::Signal< void (Dali::Actor,bool) > const *self){
1448          return self->Empty();
1449       }
1450 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Actor,bool) > const *self){
1451         return self->GetConnectionCount();
1452       }
1453 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)){
1454         self->Connect( func );
1455       }
1456 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)){
1457         self->Disconnect( func );
1458       }
1459 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){
1460         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1461 /*@SWIG@*/ self->Emit( arg1, arg2 );
1462       }
1463 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > const *self){
1464          return self->Empty();
1465       }
1466 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){
1467         return self->GetConnectionCount();
1468       }
1469 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)){
1470         self->Connect( func );
1471       }
1472 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)){
1473         self->Disconnect( func );
1474       }
1475 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){
1476         /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1477 /*@SWIG@*/ self->Emit( arg1, arg2 );
1478       }
1479 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1480          return self->Empty();
1481       }
1482 SWIGINTERN std::size_t Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount(Dali::Signal< bool (Dali::Toolkit::Button) > const *self){
1483         return self->GetConnectionCount();
1484       }
1485 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)){
1486           self->Connect( func );
1487       }
1488 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)){
1489           self->Disconnect( func );
1490       }
1491 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(Dali::Signal< bool (Dali::Toolkit::Button) > *self,Dali::Toolkit::Button arg){
1492           return self->Emit( arg );
1493       }
1494 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1495          return self->Empty();
1496       }
1497 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *self){
1498         return self->GetConnectionCount();
1499       }
1500 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)){
1501           self->Connect( func );
1502       }
1503 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)){
1504           self->Disconnect( func );
1505       }
1506 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *self,Dali::Toolkit::GaussianBlurView arg){
1507           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1508 /*@SWIG@*/ self->Emit( arg );
1509       }
1510 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){
1511          return self->Empty();
1512       }
1513 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){
1514         return self->GetConnectionCount();
1515       }
1516 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)){
1517           return self->Connect( func );
1518       }
1519 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)){
1520           self->Disconnect( func );
1521       }
1522 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){
1523           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1524 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1525       }
1526 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1527          return self->Empty();
1528       }
1529 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *self){
1530         return self->GetConnectionCount();
1531       }
1532 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)){
1533           self->Connect( func );
1534       }
1535 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)){
1536           self->Disconnect( func );
1537       }
1538 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::PageTurnView) > *self,Dali::Toolkit::PageTurnView arg){
1539           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1540 /*@SWIG@*/ self->Emit( arg );
1541       }
1542 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){
1543          return self->Empty();
1544       }
1545 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){
1546         return self->GetConnectionCount();
1547       }
1548 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)){
1549           return self->Connect( func );
1550       }
1551 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)){
1552           self->Disconnect( func );
1553       }
1554 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){
1555           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1556 /*@SWIG@*/ self->Emit( arg1, arg2, arg3 );
1557       }
1558 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){
1559          return self->Empty();
1560       }
1561 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){
1562         return self->GetConnectionCount();
1563       }
1564 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 &)){
1565           self->Connect( func );
1566       }
1567 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 &)){
1568           self->Disconnect( func );
1569       }
1570 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){
1571           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1572 /*@SWIG@*/ self->Emit( arg );
1573       }
1574 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Vector2 const &) > const *self){
1575          return self->Empty();
1576       }
1577 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){
1578         return self->GetConnectionCount();
1579       }
1580 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 &)){
1581           self->Connect( func );
1582       }
1583 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 &)){
1584           self->Disconnect( func );
1585       }
1586 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){
1587           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1588 /*@SWIG@*/ self->Emit( arg );
1589       }
1590
1591
1592 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){
1593          return self->Empty();
1594       }
1595 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){
1596         return self->GetConnectionCount();
1597       }
1598 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 &)){
1599         self->Connect( func );
1600       }
1601 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 &)){
1602         self->Disconnect( func );
1603       }
1604 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){
1605         return self->Emit( arg1, arg2 );
1606       }
1607 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1608          return self->Empty();
1609       }
1610 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::Control) > const *self){
1611         return self->GetConnectionCount();
1612       }
1613 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)){
1614           self->Connect( func );
1615       }
1616 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)){
1617           self->Disconnect( func );
1618       }
1619 SWIGINTERN void Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(Dali::Signal< void (Dali::Toolkit::Control) > *self,Dali::Toolkit::Control arg){
1620           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1621 /*@SWIG@*/ self->Emit( arg );
1622       }
1623 SWIGINTERN bool Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1624          return self->Empty();
1625       }
1626 SWIGINTERN std::size_t Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount(Dali::Signal< void (Dali::Toolkit::VideoView &) > const *self){
1627         return self->GetConnectionCount();
1628       }
1629 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 &)){
1630           self->Connect( func );
1631       }
1632 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 &)){
1633           self->Disconnect( func );
1634       }
1635 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){
1636           /*@SWIG:SWIG/signals.i,185,NO_RETURN_FUNC@*/;
1637 /*@SWIG@*/ self->Emit( arg );
1638       }
1639 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *self){
1640          return self->Empty();
1641       }
1642 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){
1643         return self->GetConnectionCount();
1644       }
1645 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)){
1646         self->Connect( func );
1647       }
1648 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)){
1649         self->Disconnect( func );
1650       }
1651 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){
1652         return self->Emit( arg1, arg2 );
1653       }
1654 SWIGINTERN bool Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty(Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *self){
1655          return self->Empty();
1656       }
1657 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){
1658         return self->GetConnectionCount();
1659       }
1660 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)){
1661         self->Connect( func );
1662       }
1663 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)){
1664         self->Disconnect( func );
1665       }
1666 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){
1667         return self->Emit( arg1, arg2 );
1668       }
1669
1670 /* ---------------------------------------------------
1671  * C++ director class methods
1672  * --------------------------------------------------- */
1673
1674 #include "dali_wrap.h"
1675
1676 /*
1677  *  Widget director
1678  */
1679 SwigDirector_WidgetImpl::SwigDirector_WidgetImpl() : Dali::Internal::Adaptor::Widget(), Swig::Director() {
1680   swig_init_callbacks();
1681 }
1682
1683 SwigDirector_WidgetImpl::~SwigDirector_WidgetImpl() {
1684 }
1685
1686 void SwigDirector_WidgetImpl::OnCreate(std::string const &contentInfo, Dali::Window window) {
1687   char * jcontentInfo = 0 ;
1688   void * jwindow  ;
1689
1690   if (!swig_callbackOnCreate) {
1691     Dali::Internal::Adaptor::Widget::OnCreate(contentInfo,window);
1692     return;
1693   } else {
1694     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1695     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1696     swig_callbackOnCreate(jcontentInfo, jwindow);
1697   }
1698 }
1699
1700 void SwigDirector_WidgetImpl::OnTerminate(std::string const &contentInfo, Dali::Widget::Termination type) {
1701   char * jcontentInfo = 0 ;
1702   int jtype  ;
1703
1704   if (!swig_callbackOnTerminate) {
1705     Dali::Internal::Adaptor::Widget::OnTerminate(contentInfo,type);
1706     return;
1707   } else {
1708     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1709     jtype = (int)type;
1710     swig_callbackOnTerminate(jcontentInfo, jtype);
1711   }
1712 }
1713
1714 void SwigDirector_WidgetImpl::OnPause() {
1715   if (!swig_callbackOnPause) {
1716     Dali::Internal::Adaptor::Widget::OnPause();
1717     return;
1718   } else {
1719     swig_callbackOnPause();
1720   }
1721 }
1722
1723 void SwigDirector_WidgetImpl::OnResume() {
1724   if (!swig_callbackOnResume) {
1725     Dali::Internal::Adaptor::Widget::OnResume();
1726     return;
1727   } else {
1728     swig_callbackOnResume();
1729   }
1730 }
1731
1732 void SwigDirector_WidgetImpl::OnResize(Dali::Window window) {
1733   void * jwindow  ;
1734
1735   if (!swig_callbackOnResize) {
1736     Dali::Internal::Adaptor::Widget::OnResize(window);
1737     return;
1738   } else {
1739     jwindow = (void *)new Dali::Window((const Dali::Window &)window);
1740     swig_callbackOnResize(jwindow);
1741   }
1742 }
1743
1744 void SwigDirector_WidgetImpl::OnUpdate(std::string const &contentInfo, int force) {
1745   char * jcontentInfo = 0 ;
1746   int jforce  ;
1747
1748   if (!swig_callbackOnUpdate) {
1749     Dali::Internal::Adaptor::Widget::OnUpdate(contentInfo,force);
1750     return;
1751   } else {
1752     jcontentInfo = SWIG_csharp_string_callback((&contentInfo)->c_str());
1753     jforce = force;
1754     swig_callbackOnUpdate(jcontentInfo, jforce);
1755   }
1756 }
1757
1758 void SwigDirector_WidgetImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1759   void * jslotObserver = 0 ;
1760   void * jcallback = 0 ;
1761
1762   if (!swig_callbackSignalConnected) {
1763     Dali::Internal::Adaptor::Widget::SignalConnected(slotObserver,callback);
1764     return;
1765   } else {
1766     jslotObserver = (void *) slotObserver;
1767     jcallback = (void *) callback;
1768     swig_callbackSignalConnected(jslotObserver, jcallback);
1769   }
1770 }
1771
1772 void SwigDirector_WidgetImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
1773   void * jslotObserver = 0 ;
1774   void * jcallback = 0 ;
1775
1776   if (!swig_callbackSignalDisconnected) {
1777     Dali::Internal::Adaptor::Widget::SignalDisconnected(slotObserver,callback);
1778     return;
1779   } else {
1780     jslotObserver = (void *) slotObserver;
1781     jcallback = (void *) callback;
1782     swig_callbackSignalDisconnected(jslotObserver, jcallback);
1783   }
1784 }
1785
1786 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) {
1787
1788   swig_callbackOnCreate = callbackOnCreate;
1789   swig_callbackOnTerminate = callbackOnTerminate;
1790   swig_callbackOnPause = callbackOnPause;
1791   swig_callbackOnResume = callbackOnResume;
1792   swig_callbackOnResize = callbackOnResize;
1793   swig_callbackOnUpdate = callbackOnUpdate;
1794   swig_callbackSignalConnected = callbackSignalConnected;
1795   swig_callbackSignalDisconnected = callbackSignalDisconnected;
1796 }
1797
1798 void SwigDirector_WidgetImpl::swig_init_callbacks() {
1799   swig_callbackOnCreate = 0;
1800   swig_callbackOnTerminate = 0;
1801   swig_callbackOnPause = 0;
1802   swig_callbackOnResume = 0;
1803   swig_callbackOnResize = 0;
1804   swig_callbackOnUpdate = 0;
1805   swig_callbackSignalConnected = 0;
1806   swig_callbackSignalDisconnected = 0;
1807 }
1808
1809
1810 SwigDirector_ViewImpl::SwigDirector_ViewImpl(Dali::Toolkit::Internal::Control::ControlBehaviour behaviourFlags) : Dali::Toolkit::Internal::Control(behaviourFlags), Swig::Director() {
1811   swig_init_callbacks();
1812 }
1813
1814 SwigDirector_ViewImpl::~SwigDirector_ViewImpl() {
1815
1816 }
1817
1818
1819 void SwigDirector_ViewImpl::OnStageConnection(int depth) {
1820   int jdepth  ;
1821
1822   if (!swig_callbackOnStageConnection) {
1823     Dali::Toolkit::Internal::Control::OnStageConnection(depth);
1824     return;
1825   } else {
1826     jdepth = depth;
1827     swig_callbackOnStageConnection(jdepth);
1828   }
1829 }
1830
1831 void SwigDirector_ViewImpl::OnStageDisconnection() {
1832   if (!swig_callbackOnStageDisconnection) {
1833     Dali::Toolkit::Internal::Control::OnStageDisconnection();
1834     return;
1835   } else {
1836     swig_callbackOnStageDisconnection();
1837   }
1838 }
1839
1840 void SwigDirector_ViewImpl::OnChildAdd(Dali::Actor &child) {
1841   void * jchild = 0 ;
1842
1843   if (!swig_callbackOnChildAdd) {
1844     Dali::Toolkit::Internal::Control::OnChildAdd(child);
1845     return;
1846   } else {
1847     jchild = (Dali::Actor *) &child;
1848     swig_callbackOnChildAdd(jchild);
1849   }
1850 }
1851
1852 void SwigDirector_ViewImpl::OnChildRemove(Dali::Actor &child) {
1853   void * jchild = 0 ;
1854
1855   if (!swig_callbackOnChildRemove) {
1856     Dali::Toolkit::Internal::Control::OnChildRemove(child);
1857     return;
1858   } else {
1859     jchild = (Dali::Actor *) &child;
1860     swig_callbackOnChildRemove(jchild);
1861   }
1862 }
1863
1864 void SwigDirector_ViewImpl::OnPropertySet(Dali::Property::Index index, Dali::Property::Value propertyValue) {
1865   int jindex  ;
1866   void * jpropertyValue  ;
1867
1868   if (!swig_callbackOnPropertySet) {
1869     Dali::Toolkit::Internal::Control::OnPropertySet(index,propertyValue);
1870     return;
1871   } else {
1872     jindex = index;
1873     jpropertyValue = (void *)new Dali::Property::Value((const Dali::Property::Value &)propertyValue);
1874     swig_callbackOnPropertySet(jindex, jpropertyValue);
1875   }
1876 }
1877
1878 void SwigDirector_ViewImpl::OnSizeSet(Dali::Vector3 const &targetSize) {
1879   void * jtargetSize = 0 ;
1880
1881   if (!swig_callbackOnSizeSet) {
1882     Dali::Toolkit::Internal::Control::OnSizeSet(targetSize);
1883     return;
1884   } else {
1885     jtargetSize = (Dali::Vector3 *) &targetSize;
1886     swig_callbackOnSizeSet(jtargetSize);
1887   }
1888 }
1889
1890 void SwigDirector_ViewImpl::OnSizeAnimation(Dali::Animation &animation, Dali::Vector3 const &targetSize) {
1891   void * janimation = 0 ;
1892   void * jtargetSize = 0 ;
1893
1894   if (!swig_callbackOnSizeAnimation) {
1895     Dali::Toolkit::Internal::Control::OnSizeAnimation(animation,targetSize);
1896     return;
1897   } else {
1898     janimation = (Dali::Animation *) &animation;
1899     jtargetSize = (Dali::Vector3 *) &targetSize;
1900     swig_callbackOnSizeAnimation(janimation, jtargetSize);
1901   }
1902 }
1903
1904 bool SwigDirector_ViewImpl::OnTouchEvent(Dali::TouchEvent const &event) {
1905   bool c_result = SwigValueInit< bool >() ;
1906   unsigned int jresult = 0 ;
1907   void * jarg0 = 0 ;
1908
1909   if (!swig_callbackOnTouchEvent) {
1910     return Dali::Toolkit::Internal::Control::OnTouchEvent(event);
1911   } else {
1912     jarg0 = (Dali::TouchEvent *) &event;
1913     jresult = (unsigned int) swig_callbackOnTouchEvent(jarg0);
1914     c_result = jresult ? true : false;
1915   }
1916   return c_result;
1917 }
1918
1919 bool SwigDirector_ViewImpl::OnHoverEvent(Dali::HoverEvent const &event) {
1920   bool c_result = SwigValueInit< bool >() ;
1921   unsigned int jresult = 0 ;
1922   void * jarg0 = 0 ;
1923
1924   if (!swig_callbackOnHoverEvent) {
1925     return Dali::Toolkit::Internal::Control::OnHoverEvent(event);
1926   } else {
1927     jarg0 = (Dali::HoverEvent *) &event;
1928     jresult = (unsigned int) swig_callbackOnHoverEvent(jarg0);
1929     c_result = jresult ? true : false;
1930   }
1931   return c_result;
1932 }
1933
1934 bool SwigDirector_ViewImpl::OnKeyEvent(Dali::KeyEvent const &event) {
1935   bool c_result = SwigValueInit< bool >() ;
1936   unsigned int jresult = 0 ;
1937   void * jarg0 = 0 ;
1938
1939   if (!swig_callbackOnKeyEvent) {
1940     return Dali::Toolkit::Internal::Control::OnKeyEvent(event);
1941   } else {
1942     jarg0 = (Dali::KeyEvent *) &event;
1943     jresult = (unsigned int) swig_callbackOnKeyEvent(jarg0);
1944     c_result = jresult ? true : false;
1945   }
1946   return c_result;
1947 }
1948
1949 bool SwigDirector_ViewImpl::OnWheelEvent(Dali::WheelEvent const &event) {
1950   bool c_result = SwigValueInit< bool >() ;
1951   unsigned int jresult = 0 ;
1952   void * jarg0 = 0 ;
1953
1954   if (!swig_callbackOnWheelEvent) {
1955     return Dali::Toolkit::Internal::Control::OnWheelEvent(event);
1956   } else {
1957     jarg0 = (Dali::WheelEvent *) &event;
1958     jresult = (unsigned int) swig_callbackOnWheelEvent(jarg0);
1959     c_result = jresult ? true : false;
1960   }
1961   return c_result;
1962 }
1963
1964 void SwigDirector_ViewImpl::OnRelayout(Dali::Vector2 const &size, Dali::RelayoutContainer &container) {
1965   void * jsize = 0 ;
1966   void * jcontainer = 0 ;
1967
1968   if (!swig_callbackOnRelayout) {
1969     Dali::Toolkit::Internal::Control::OnRelayout(size,container);
1970     return;
1971   } else {
1972     jsize = (Dali::Vector2 *) &size;
1973     jcontainer = (Dali::RelayoutContainer *) &container;
1974     swig_callbackOnRelayout(jsize, jcontainer);
1975   }
1976 }
1977
1978 void SwigDirector_ViewImpl::OnSetResizePolicy(Dali::ResizePolicy::Type policy, Dali::Dimension::Type dimension) {
1979   int jpolicy  ;
1980   int jdimension  ;
1981
1982   if (!swig_callbackOnSetResizePolicy) {
1983     Dali::Toolkit::Internal::Control::OnSetResizePolicy(policy,dimension);
1984     return;
1985   } else {
1986     jpolicy = (int)policy;
1987     jdimension = (int)dimension;
1988     swig_callbackOnSetResizePolicy(jpolicy, jdimension);
1989   }
1990 }
1991
1992 Dali::Vector3 SwigDirector_ViewImpl::GetNaturalSize() {
1993   Dali::Vector3 c_result ;
1994   void * jresult = 0 ;
1995
1996   if (!swig_callbackGetNaturalSize) {
1997     return Dali::Toolkit::Internal::Control::GetNaturalSize();
1998   } else {
1999     jresult = (void *) swig_callbackGetNaturalSize();
2000     if (!jresult) {
2001       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Vector3", 0);
2002       return c_result;
2003     }
2004     c_result = *(Dali::Vector3 *)jresult;
2005   }
2006   return c_result;
2007 }
2008
2009 float SwigDirector_ViewImpl::CalculateChildSize(Dali::Actor const &child, Dali::Dimension::Type dimension) {
2010   float c_result = SwigValueInit< float >() ;
2011   float jresult = 0 ;
2012   void * jchild = 0 ;
2013   int jdimension  ;
2014
2015   if (!swig_callbackCalculateChildSize) {
2016     return Dali::Toolkit::Internal::Control::CalculateChildSize(child,dimension);
2017   } else {
2018     jchild = (Dali::Actor *) &child;
2019     jdimension = (int)dimension;
2020     jresult = (float) swig_callbackCalculateChildSize(jchild, jdimension);
2021     c_result = (float)jresult;
2022   }
2023   return c_result;
2024 }
2025
2026 float SwigDirector_ViewImpl::GetHeightForWidth(float width) {
2027   float c_result = SwigValueInit< float >() ;
2028   float jresult = 0 ;
2029   float jwidth  ;
2030
2031   if (!swig_callbackGetHeightForWidth) {
2032     return Dali::Toolkit::Internal::Control::GetHeightForWidth(width);
2033   } else {
2034     jwidth = width;
2035     jresult = (float) swig_callbackGetHeightForWidth(jwidth);
2036     c_result = (float)jresult;
2037   }
2038   return c_result;
2039 }
2040
2041 float SwigDirector_ViewImpl::GetWidthForHeight(float height) {
2042   float c_result = SwigValueInit< float >() ;
2043   float jresult = 0 ;
2044   float jheight  ;
2045
2046   if (!swig_callbackGetWidthForHeight) {
2047     return Dali::Toolkit::Internal::Control::GetWidthForHeight(height);
2048   } else {
2049     jheight = height;
2050     jresult = (float) swig_callbackGetWidthForHeight(jheight);
2051     c_result = (float)jresult;
2052   }
2053   return c_result;
2054 }
2055
2056 bool SwigDirector_ViewImpl::RelayoutDependentOnChildren(Dali::Dimension::Type dimension) {
2057   bool c_result = SwigValueInit< bool >() ;
2058   unsigned int jresult = 0 ;
2059   int jdimension  ;
2060
2061   if (!swig_callbackRelayoutDependentOnChildren__SWIG_0) {
2062     return Dali::Toolkit::Internal::Control::RelayoutDependentOnChildren(dimension);
2063   } else {
2064     jdimension = (int)dimension;
2065     jresult = (unsigned int) swig_callbackRelayoutDependentOnChildren__SWIG_0(jdimension);
2066     c_result = jresult ? true : false;
2067   }
2068   return c_result;
2069 }
2070
2071 void SwigDirector_ViewImpl::OnCalculateRelayoutSize(Dali::Dimension::Type dimension) {
2072   int jdimension  ;
2073
2074   if (!swig_callbackOnCalculateRelayoutSize) {
2075     Dali::Toolkit::Internal::Control::OnCalculateRelayoutSize(dimension);
2076     return;
2077   } else {
2078     jdimension = (int)dimension;
2079     swig_callbackOnCalculateRelayoutSize(jdimension);
2080   }
2081 }
2082
2083 void SwigDirector_ViewImpl::OnLayoutNegotiated(float size, Dali::Dimension::Type dimension) {
2084   float jsize  ;
2085   int jdimension  ;
2086
2087   if (!swig_callbackOnLayoutNegotiated) {
2088     Dali::Toolkit::Internal::Control::OnLayoutNegotiated(size,dimension);
2089     return;
2090   } else {
2091     jsize = size;
2092     jdimension = (int)dimension;
2093     swig_callbackOnLayoutNegotiated(jsize, jdimension);
2094   }
2095 }
2096
2097 Dali::CustomActorImpl::Extension *SwigDirector_ViewImpl::GetExtension() {
2098   return Dali::CustomActorImpl::GetExtension();
2099 }
2100
2101 void SwigDirector_ViewImpl::OnInitialize() {
2102   if (!swig_callbackOnInitialize) {
2103     Dali::Toolkit::Internal::Control::OnInitialize();
2104     return;
2105   } else {
2106     swig_callbackOnInitialize();
2107   }
2108 }
2109
2110 void SwigDirector_ViewImpl::OnStyleChange(Dali::Toolkit::StyleManager styleManager, Dali::StyleChange::Type change) {
2111   void * jstyleManager  ;
2112   int jchange  ;
2113
2114   if (!swig_callbackOnStyleChange) {
2115     Dali::Toolkit::Internal::Control::OnStyleChange(styleManager,change);
2116     return;
2117   } else {
2118     jstyleManager = (void *)new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)styleManager);
2119     jchange = (int)change;
2120     swig_callbackOnStyleChange(jstyleManager, jchange);
2121   }
2122 }
2123
2124 bool SwigDirector_ViewImpl::OnAccessibilityActivated() {
2125   bool c_result = SwigValueInit< bool >() ;
2126   unsigned int jresult = 0 ;
2127
2128   if (!swig_callbackOnAccessibilityActivated) {
2129     return Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
2130   } else {
2131     jresult = (unsigned int) swig_callbackOnAccessibilityActivated();
2132     c_result = jresult ? true : false;
2133   }
2134   return c_result;
2135 }
2136
2137 bool SwigDirector_ViewImpl::OnAccessibilityPan(Dali::PanGesture gesture) {
2138   bool c_result = SwigValueInit< bool >() ;
2139   unsigned int jresult = 0 ;
2140   void * jgesture  ;
2141
2142   if (!swig_callbackOnAccessibilityPan) {
2143     return Dali::Toolkit::Internal::Control::OnAccessibilityPan(gesture);
2144   } else {
2145     jgesture = (void *)new Dali::PanGesture((const Dali::PanGesture &)gesture);
2146     jresult = (unsigned int) swig_callbackOnAccessibilityPan(jgesture);
2147     c_result = jresult ? true : false;
2148   }
2149   return c_result;
2150 }
2151
2152 bool SwigDirector_ViewImpl::OnAccessibilityTouch(Dali::TouchEvent const &touchEvent) {
2153   bool c_result = SwigValueInit< bool >() ;
2154   unsigned int jresult = 0 ;
2155   void * jtouchEvent = 0 ;
2156
2157   if (!swig_callbackOnAccessibilityTouch) {
2158     return Dali::Toolkit::Internal::Control::OnAccessibilityTouch(touchEvent);
2159   } else {
2160     jtouchEvent = (Dali::TouchEvent *) &touchEvent;
2161     jresult = (unsigned int) swig_callbackOnAccessibilityTouch(jtouchEvent);
2162     c_result = jresult ? true : false;
2163   }
2164   return c_result;
2165 }
2166
2167 bool SwigDirector_ViewImpl::OnAccessibilityValueChange(bool isIncrease) {
2168   bool c_result = SwigValueInit< bool >() ;
2169   unsigned int jresult = 0 ;
2170   unsigned int jisIncrease  ;
2171
2172   if (!swig_callbackOnAccessibilityValueChange) {
2173     return Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(isIncrease);
2174   } else {
2175     jisIncrease = isIncrease;
2176     jresult = (unsigned int) swig_callbackOnAccessibilityValueChange(jisIncrease);
2177     c_result = jresult ? true : false;
2178   }
2179   return c_result;
2180 }
2181
2182 bool SwigDirector_ViewImpl::OnAccessibilityZoom() {
2183   bool c_result = SwigValueInit< bool >() ;
2184   unsigned int jresult = 0 ;
2185
2186   if (!swig_callbackOnAccessibilityZoom) {
2187     return Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
2188   } else {
2189     jresult = (unsigned int) swig_callbackOnAccessibilityZoom();
2190     c_result = jresult ? true : false;
2191   }
2192   return c_result;
2193 }
2194
2195 void SwigDirector_ViewImpl::OnKeyInputFocusGained() {
2196   if (!swig_callbackOnKeyInputFocusGained) {
2197     Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
2198     return;
2199   } else {
2200     swig_callbackOnKeyInputFocusGained();
2201   }
2202 }
2203
2204 void SwigDirector_ViewImpl::OnKeyInputFocusLost() {
2205   if (!swig_callbackOnKeyInputFocusLost) {
2206     Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
2207     return;
2208   } else {
2209     swig_callbackOnKeyInputFocusLost();
2210   }
2211 }
2212
2213 Dali::Actor SwigDirector_ViewImpl::GetNextKeyboardFocusableActor(Dali::Actor currentFocusedActor, Dali::Toolkit::Control::KeyboardFocus::Direction direction, bool loopEnabled) {
2214   Dali::Actor c_result ;
2215   void * jresult = 0 ;
2216   void * jcurrentFocusedActor  ;
2217   int jdirection  ;
2218   unsigned int jloopEnabled  ;
2219
2220   if (!swig_callbackGetNextKeyboardFocusableActor) {
2221     return Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(currentFocusedActor,direction,loopEnabled);
2222   } else {
2223     jcurrentFocusedActor = (void *)new Dali::Actor((const Dali::Actor &)currentFocusedActor);
2224     jdirection = (int)direction;
2225     jloopEnabled = loopEnabled;
2226     jresult = (void *) swig_callbackGetNextKeyboardFocusableActor(jcurrentFocusedActor, jdirection, jloopEnabled);
2227     if (!jresult) {
2228       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2229       return c_result;
2230     }
2231     c_result = *(Dali::Actor *)jresult;
2232   }
2233   return c_result;
2234 }
2235
2236 void SwigDirector_ViewImpl::OnKeyboardFocusChangeCommitted(Dali::Actor commitedFocusableActor) {
2237   void * jcommitedFocusableActor  ;
2238
2239   if (!swig_callbackOnKeyboardFocusChangeCommitted) {
2240     Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(commitedFocusableActor);
2241     return;
2242   } else {
2243     jcommitedFocusableActor = (void *)new Dali::Actor((const Dali::Actor &)commitedFocusableActor);
2244     swig_callbackOnKeyboardFocusChangeCommitted(jcommitedFocusableActor);
2245   }
2246 }
2247
2248 bool SwigDirector_ViewImpl::OnKeyboardEnter() {
2249   bool c_result = SwigValueInit< bool >() ;
2250   unsigned int jresult = 0 ;
2251
2252   if (!swig_callbackOnKeyboardEnter) {
2253     return Dali::Toolkit::Internal::Control::OnKeyboardEnter();
2254   } else {
2255     jresult = (unsigned int) swig_callbackOnKeyboardEnter();
2256     c_result = jresult ? true : false;
2257   }
2258   return c_result;
2259 }
2260
2261 void SwigDirector_ViewImpl::OnPinch(Dali::PinchGesture const &pinch) {
2262   void * jpinch = 0 ;
2263
2264   if (!swig_callbackOnPinch) {
2265     Dali::Toolkit::Internal::Control::OnPinch(pinch);
2266     return;
2267   } else {
2268     jpinch = (Dali::PinchGesture *) &pinch;
2269     swig_callbackOnPinch(jpinch);
2270   }
2271 }
2272
2273 void SwigDirector_ViewImpl::OnPan(Dali::PanGesture const &pan) {
2274   void * jpan = 0 ;
2275
2276   if (!swig_callbackOnPan) {
2277     Dali::Toolkit::Internal::Control::OnPan(pan);
2278     return;
2279   } else {
2280     jpan = (Dali::PanGesture *) &pan;
2281     swig_callbackOnPan(jpan);
2282   }
2283 }
2284
2285 void SwigDirector_ViewImpl::OnTap(Dali::TapGesture const &tap) {
2286   void * jtap = 0 ;
2287
2288   if (!swig_callbackOnTap) {
2289     Dali::Toolkit::Internal::Control::OnTap(tap);
2290     return;
2291   } else {
2292     jtap = (Dali::TapGesture *) &tap;
2293     swig_callbackOnTap(jtap);
2294   }
2295 }
2296
2297 void SwigDirector_ViewImpl::OnLongPress(Dali::LongPressGesture const &longPress) {
2298   void * jlongPress = 0 ;
2299
2300   if (!swig_callbackOnLongPress) {
2301     Dali::Toolkit::Internal::Control::OnLongPress(longPress);
2302     return;
2303   } else {
2304     jlongPress = (Dali::LongPressGesture *) &longPress;
2305     swig_callbackOnLongPress(jlongPress);
2306   }
2307 }
2308
2309 void SwigDirector_ViewImpl::SignalConnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2310   void * jslotObserver = 0 ;
2311   void * jcallback = 0 ;
2312
2313   if (!swig_callbackSignalConnected) {
2314     Dali::Toolkit::Internal::Control::SignalConnected(slotObserver,callback);
2315     return;
2316   } else {
2317     jslotObserver = (void *) slotObserver;
2318     jcallback = (void *) callback;
2319     swig_callbackSignalConnected(jslotObserver, jcallback);
2320   }
2321 }
2322
2323 void SwigDirector_ViewImpl::SignalDisconnected(Dali::SlotObserver *slotObserver, Dali::CallbackBase *callback) {
2324   void * jslotObserver = 0 ;
2325   void * jcallback = 0 ;
2326
2327   if (!swig_callbackSignalDisconnected) {
2328     Dali::Toolkit::Internal::Control::SignalDisconnected(slotObserver,callback);
2329     return;
2330   } else {
2331     jslotObserver = (void *) slotObserver;
2332     jcallback = (void *) callback;
2333     swig_callbackSignalDisconnected(jslotObserver, jcallback);
2334   }
2335 }
2336
2337 Dali::Toolkit::Internal::Control::Extension *SwigDirector_ViewImpl::GetControlExtension() {
2338   return Dali::Toolkit::Internal::Control::GetControlExtension();
2339 }
2340
2341 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_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) {
2342   swig_callbackOnStageConnection = callbackOnStageConnection;
2343   swig_callbackOnStageDisconnection = callbackOnStageDisconnection;
2344   swig_callbackOnChildAdd = callbackOnChildAdd;
2345   swig_callbackOnChildRemove = callbackOnChildRemove;
2346   swig_callbackOnPropertySet = callbackOnPropertySet;
2347   swig_callbackOnSizeSet = callbackOnSizeSet;
2348   swig_callbackOnSizeAnimation = callbackOnSizeAnimation;
2349   swig_callbackOnTouchEvent = callbackOnTouchEvent;
2350   swig_callbackOnHoverEvent = callbackOnHoverEvent;
2351   swig_callbackOnKeyEvent = callbackOnKeyEvent;
2352   swig_callbackOnWheelEvent = callbackOnWheelEvent;
2353   swig_callbackOnRelayout = callbackOnRelayout;
2354   swig_callbackOnSetResizePolicy = callbackOnSetResizePolicy;
2355   swig_callbackGetNaturalSize = callbackGetNaturalSize;
2356   swig_callbackCalculateChildSize = callbackCalculateChildSize;
2357   swig_callbackGetHeightForWidth = callbackGetHeightForWidth;
2358   swig_callbackGetWidthForHeight = callbackGetWidthForHeight;
2359   swig_callbackRelayoutDependentOnChildren__SWIG_0 = callbackRelayoutDependentOnChildren__SWIG_0;
2360   swig_callbackRelayoutDependentOnChildren__SWIG_1 = callbackRelayoutDependentOnChildren__SWIG_1;
2361   swig_callbackOnCalculateRelayoutSize = callbackOnCalculateRelayoutSize;
2362   swig_callbackOnLayoutNegotiated = callbackOnLayoutNegotiated;
2363   swig_callbackOnInitialize = callbackOnInitialize;
2364   swig_callbackOnStyleChange = callbackOnStyleChange;
2365   swig_callbackOnAccessibilityActivated = callbackOnAccessibilityActivated;
2366   swig_callbackOnAccessibilityPan = callbackOnAccessibilityPan;
2367   swig_callbackOnAccessibilityTouch = callbackOnAccessibilityTouch;
2368   swig_callbackOnAccessibilityValueChange = callbackOnAccessibilityValueChange;
2369   swig_callbackOnAccessibilityZoom = callbackOnAccessibilityZoom;
2370   swig_callbackOnKeyInputFocusGained = callbackOnKeyInputFocusGained;
2371   swig_callbackOnKeyInputFocusLost = callbackOnKeyInputFocusLost;
2372   swig_callbackGetNextKeyboardFocusableActor = callbackGetNextKeyboardFocusableActor;
2373   swig_callbackOnKeyboardFocusChangeCommitted = callbackOnKeyboardFocusChangeCommitted;
2374   swig_callbackOnKeyboardEnter = callbackOnKeyboardEnter;
2375   swig_callbackOnPinch = callbackOnPinch;
2376   swig_callbackOnPan = callbackOnPan;
2377   swig_callbackOnTap = callbackOnTap;
2378   swig_callbackOnLongPress = callbackOnLongPress;
2379   swig_callbackSignalConnected = callbackSignalConnected;
2380   swig_callbackSignalDisconnected = callbackSignalDisconnected;
2381 }
2382
2383 void SwigDirector_ViewImpl::swig_init_callbacks() {
2384   swig_callbackOnStageConnection = 0;
2385   swig_callbackOnStageDisconnection = 0;
2386   swig_callbackOnChildAdd = 0;
2387   swig_callbackOnChildRemove = 0;
2388   swig_callbackOnPropertySet = 0;
2389   swig_callbackOnSizeSet = 0;
2390   swig_callbackOnSizeAnimation = 0;
2391   swig_callbackOnTouchEvent = 0;
2392   swig_callbackOnHoverEvent = 0;
2393   swig_callbackOnKeyEvent = 0;
2394   swig_callbackOnWheelEvent = 0;
2395   swig_callbackOnRelayout = 0;
2396   swig_callbackOnSetResizePolicy = 0;
2397   swig_callbackGetNaturalSize = 0;
2398   swig_callbackCalculateChildSize = 0;
2399   swig_callbackGetHeightForWidth = 0;
2400   swig_callbackGetWidthForHeight = 0;
2401   swig_callbackRelayoutDependentOnChildren__SWIG_0 = 0;
2402   swig_callbackRelayoutDependentOnChildren__SWIG_1 = 0;
2403   swig_callbackOnCalculateRelayoutSize = 0;
2404   swig_callbackOnLayoutNegotiated = 0;
2405   swig_callbackOnInitialize = 0;
2406   swig_callbackOnStyleChange = 0;
2407   swig_callbackOnAccessibilityActivated = 0;
2408   swig_callbackOnAccessibilityPan = 0;
2409   swig_callbackOnAccessibilityTouch = 0;
2410   swig_callbackOnAccessibilityValueChange = 0;
2411   swig_callbackOnAccessibilityZoom = 0;
2412   swig_callbackOnKeyInputFocusGained = 0;
2413   swig_callbackOnKeyInputFocusLost = 0;
2414   swig_callbackGetNextKeyboardFocusableActor = 0;
2415   swig_callbackOnKeyboardFocusChangeCommitted = 0;
2416   swig_callbackOnKeyboardEnter = 0;
2417   swig_callbackOnPinch = 0;
2418   swig_callbackOnPan = 0;
2419   swig_callbackOnTap = 0;
2420   swig_callbackOnLongPress = 0;
2421   swig_callbackSignalConnected = 0;
2422   swig_callbackSignalDisconnected = 0;
2423 }
2424
2425 SwigDirector_ItemFactory::SwigDirector_ItemFactory() : Dali::Toolkit::ItemFactory(), Swig::Director() {
2426   swig_init_callbacks();
2427 }
2428
2429 SwigDirector_ItemFactory::~SwigDirector_ItemFactory() {
2430
2431 }
2432
2433
2434 unsigned int SwigDirector_ItemFactory::GetNumberOfItems() {
2435   unsigned int c_result = SwigValueInit< unsigned int >() ;
2436   unsigned int jresult = 0 ;
2437
2438   if (!swig_callbackGetNumberOfItems) {
2439     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::GetNumberOfItems");
2440   } else {
2441     jresult = (unsigned int) swig_callbackGetNumberOfItems();
2442     c_result = (unsigned int)jresult;
2443   }
2444   return c_result;
2445 }
2446
2447 Dali::Actor SwigDirector_ItemFactory::NewItem(unsigned int itemId) {
2448   Dali::Actor c_result ;
2449   void * jresult = 0 ;
2450   unsigned int jitemId  ;
2451
2452   if (!swig_callbackNewItem) {
2453     throw Swig::DirectorPureVirtualException("Dali::Toolkit::ItemFactory::NewItem");
2454   } else {
2455     jitemId = itemId;
2456     jresult = (void *) swig_callbackNewItem(jitemId);
2457     if (!jresult) {
2458       SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Unexpected null return for type Dali::Actor", 0);
2459       return c_result;
2460     }
2461     c_result = *(Dali::Actor *)jresult;
2462   }
2463   return c_result;
2464 }
2465
2466 void SwigDirector_ItemFactory::ItemReleased(unsigned int itemId, Dali::Actor actor) {
2467   unsigned int jitemId  ;
2468   void * jactor  ;
2469
2470   if (!swig_callbackItemReleased) {
2471     Dali::Toolkit::ItemFactory::ItemReleased(itemId,actor);
2472     return;
2473   } else {
2474     jitemId = itemId;
2475     jactor = (void *)new Dali::Actor((const Dali::Actor &)actor);
2476     swig_callbackItemReleased(jitemId, jactor);
2477   }
2478 }
2479
2480 Dali::Toolkit::ItemFactory::Extension *SwigDirector_ItemFactory::GetExtension() {
2481   return Dali::Toolkit::ItemFactory::GetExtension();
2482 }
2483
2484 void SwigDirector_ItemFactory::swig_connect_director(SWIG_Callback0_t callbackGetNumberOfItems, SWIG_Callback1_t callbackNewItem, SWIG_Callback2_t callbackItemReleased) {
2485   swig_callbackGetNumberOfItems = callbackGetNumberOfItems;
2486   swig_callbackNewItem = callbackNewItem;
2487   swig_callbackItemReleased = callbackItemReleased;
2488 }
2489
2490 void SwigDirector_ItemFactory::swig_init_callbacks() {
2491   swig_callbackGetNumberOfItems = 0;
2492   swig_callbackNewItem = 0;
2493   swig_callbackItemReleased = 0;
2494 }
2495
2496 SwigDirector_CustomAlgorithmInterface::SwigDirector_CustomAlgorithmInterface() : Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface(), Swig::Director() {
2497   swig_init_callbacks();
2498 }
2499
2500 SwigDirector_CustomAlgorithmInterface::~SwigDirector_CustomAlgorithmInterface() {
2501
2502 }
2503
2504
2505 Dali::Actor SwigDirector_CustomAlgorithmInterface::GetNextFocusableActor(Dali::Actor current, Dali::Actor proposed, Dali::Toolkit::Control::KeyboardFocus::Direction direction) {
2506   Dali::Actor c_result ;
2507   void * jresult = 0 ;
2508   void * jcurrent  ;
2509   void * jproposed  ;
2510   int jdirection  ;
2511
2512   if (!swig_callbackGetNextFocusableActor) {
2513     throw Swig::DirectorPureVirtualException("Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface::GetNextFocusableActor");
2514   } else {
2515     jcurrent = (void *)new Dali::Actor((const Dali::Actor &)current);
2516     jproposed = (void *)new Dali::Actor((const Dali::Actor &)proposed);
2517     jdirection = (int)direction;
2518     jresult = (void *) swig_callbackGetNextFocusableActor(jcurrent, jproposed, jdirection);
2519     if (!jresult) {
2520       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__);
2521       return c_result;
2522     }
2523     c_result = *(Dali::Actor *)jresult;
2524   }
2525   return c_result;
2526 }
2527
2528 void SwigDirector_CustomAlgorithmInterface::swig_connect_director(SWIG_Callback0_t callbackGetNextFocusableActor) {
2529   swig_callbackGetNextFocusableActor = callbackGetNextFocusableActor;
2530 }
2531
2532 void SwigDirector_CustomAlgorithmInterface::swig_init_callbacks() {
2533   swig_callbackGetNextFocusableActor = 0;
2534 }
2535
2536
2537 #ifdef __cplusplus
2538 extern "C" {
2539 #endif
2540
2541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_floatp() {
2542   void * jresult ;
2543   floatp *result = 0 ;
2544
2545   {
2546     try {
2547       result = (floatp *)new_floatp();
2548     } catch (std::out_of_range& e) {
2549       {
2550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2551       };
2552     } catch (std::exception& e) {
2553       {
2554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2555       };
2556     } catch (DaliException e) {
2557       {
2558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2559       };
2560     } catch (...) {
2561       {
2562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2563       };
2564     }
2565   }
2566   jresult = (void *)result;
2567   return jresult;
2568 }
2569
2570
2571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_floatp(void * jarg1) {
2572   floatp *arg1 = (floatp *) 0 ;
2573
2574   arg1 = (floatp *)jarg1;
2575   {
2576     try {
2577       delete_floatp(arg1);
2578     } catch (std::out_of_range& e) {
2579       {
2580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2581       };
2582     } catch (std::exception& e) {
2583       {
2584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2585       };
2586     } catch (Dali::DaliException e) {
2587       {
2588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2589       };
2590     } catch (...) {
2591       {
2592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2593       };
2594     }
2595   }
2596
2597 }
2598
2599
2600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_floatp_assign(void * jarg1, float jarg2) {
2601   floatp *arg1 = (floatp *) 0 ;
2602   float arg2 ;
2603
2604   arg1 = (floatp *)jarg1;
2605   arg2 = (float)jarg2;
2606   {
2607     try {
2608       floatp_assign(arg1,arg2);
2609     } catch (std::out_of_range& e) {
2610       {
2611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2612       };
2613     } catch (std::exception& e) {
2614       {
2615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2616       };
2617     } catch (Dali::DaliException e) {
2618       {
2619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2620       };
2621     } catch (...) {
2622       {
2623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2624       };
2625     }
2626   }
2627
2628 }
2629
2630
2631 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_floatp_value(void * jarg1) {
2632   float jresult ;
2633   floatp *arg1 = (floatp *) 0 ;
2634   float result;
2635
2636   arg1 = (floatp *)jarg1;
2637   {
2638     try {
2639       result = (float)floatp_value(arg1);
2640     } catch (std::out_of_range& e) {
2641       {
2642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2643       };
2644     } catch (std::exception& e) {
2645       {
2646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2647       };
2648     } catch (DaliException e) {
2649       {
2650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2651       };
2652     } catch (...) {
2653       {
2654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2655       };
2656     }
2657   }
2658   jresult = result;
2659   return jresult;
2660 }
2661
2662
2663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_cast(void * jarg1) {
2664   void * jresult ;
2665   floatp *arg1 = (floatp *) 0 ;
2666   float *result = 0 ;
2667
2668   arg1 = (floatp *)jarg1;
2669   {
2670     try {
2671       result = (float *)floatp_cast(arg1);
2672     } catch (std::out_of_range& e) {
2673       {
2674         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2675       };
2676     } catch (std::exception& e) {
2677       {
2678         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2679       };
2680     } catch (Dali::DaliException e) {
2681       {
2682         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2683       };
2684     } catch (...) {
2685       {
2686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2687       };
2688     }
2689   }
2690
2691   jresult = (void *)result;
2692   return jresult;
2693 }
2694
2695
2696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_floatp_frompointer(void * jarg1) {
2697   void * jresult ;
2698   float *arg1 = (float *) 0 ;
2699   floatp *result = 0 ;
2700
2701   arg1 = (float *)jarg1;
2702   {
2703     try {
2704       result = (floatp *)floatp_frompointer(arg1);
2705     } catch (std::out_of_range& e) {
2706       {
2707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2708       };
2709     } catch (std::exception& e) {
2710       {
2711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2712       };
2713     } catch (Dali::DaliException e) {
2714       {
2715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2716       };
2717     } catch (...) {
2718       {
2719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2720       };
2721     }
2722   }
2723
2724   jresult = (void *)result;
2725   return jresult;
2726 }
2727
2728
2729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_intp() {
2730   void * jresult ;
2731   intp *result = 0 ;
2732
2733   {
2734     try {
2735       result = (intp *)new_intp();
2736     } catch (std::out_of_range& e) {
2737       {
2738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2739       };
2740     } catch (std::exception& e) {
2741       {
2742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2743       };
2744     } catch (Dali::DaliException e) {
2745       {
2746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2747       };
2748     } catch (...) {
2749       {
2750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2751       };
2752     }
2753   }
2754
2755   jresult = (void *)result;
2756   return jresult;
2757 }
2758
2759
2760 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_intp(void * jarg1) {
2761   intp *arg1 = (intp *) 0 ;
2762
2763   arg1 = (intp *)jarg1;
2764   {
2765     try {
2766       delete_intp(arg1);
2767     } catch (std::out_of_range& e) {
2768       {
2769         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2770       };
2771     } catch (std::exception& e) {
2772       {
2773         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2774       };
2775     } catch (Dali::DaliException e) {
2776       {
2777         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2778       };
2779     } catch (...) {
2780       {
2781         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2782       };
2783     }
2784   }
2785
2786 }
2787
2788
2789 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_intp_assign(void * jarg1, int jarg2) {
2790   intp *arg1 = (intp *) 0 ;
2791   int arg2 ;
2792
2793   arg1 = (intp *)jarg1;
2794   arg2 = (int)jarg2;
2795   {
2796     try {
2797       intp_assign(arg1,arg2);
2798     } catch (std::out_of_range& e) {
2799       {
2800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2801       };
2802     } catch (std::exception& e) {
2803       {
2804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2805       };
2806     } catch (Dali::DaliException e) {
2807       {
2808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2809       };
2810     } catch (...) {
2811       {
2812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2813       };
2814     }
2815   }
2816
2817 }
2818
2819
2820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_intp_value(void * jarg1) {
2821   int jresult ;
2822   intp *arg1 = (intp *) 0 ;
2823   int result;
2824
2825   arg1 = (intp *)jarg1;
2826   {
2827     try {
2828       result = (int)intp_value(arg1);
2829     } catch (std::out_of_range& e) {
2830       {
2831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2832       };
2833     } catch (std::exception& e) {
2834       {
2835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2836       };
2837     } catch (Dali::DaliException e) {
2838       {
2839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2840       };
2841     } catch (...) {
2842       {
2843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2844       };
2845     }
2846   }
2847
2848   jresult = result;
2849   return jresult;
2850 }
2851
2852
2853 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_cast(void * jarg1) {
2854   void * jresult ;
2855   intp *arg1 = (intp *) 0 ;
2856   int *result = 0 ;
2857
2858   arg1 = (intp *)jarg1;
2859   {
2860     try {
2861       result = (int *)intp_cast(arg1);
2862     } catch (std::out_of_range& e) {
2863       {
2864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2865       };
2866     } catch (std::exception& e) {
2867       {
2868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2869       };
2870     } catch (Dali::DaliException e) {
2871       {
2872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2873       };
2874     } catch (...) {
2875       {
2876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2877       };
2878     }
2879   }
2880
2881   jresult = (void *)result;
2882   return jresult;
2883 }
2884
2885
2886 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_intp_frompointer(void * jarg1) {
2887   void * jresult ;
2888   int *arg1 = (int *) 0 ;
2889   intp *result = 0 ;
2890
2891   arg1 = (int *)jarg1;
2892   {
2893     try {
2894       result = (intp *)intp_frompointer(arg1);
2895     } catch (std::out_of_range& e) {
2896       {
2897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2898       };
2899     } catch (std::exception& e) {
2900       {
2901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2902       };
2903     } catch (Dali::DaliException e) {
2904       {
2905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2906       };
2907     } catch (...) {
2908       {
2909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2910       };
2911     }
2912   }
2913
2914   jresult = (void *)result;
2915   return jresult;
2916 }
2917
2918
2919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_doublep() {
2920   void * jresult ;
2921   doublep *result = 0 ;
2922
2923   {
2924     try {
2925       result = (doublep *)new_doublep();
2926     } catch (std::out_of_range& e) {
2927       {
2928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
2929       };
2930     } catch (std::exception& e) {
2931       {
2932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
2933       };
2934     } catch (Dali::DaliException e) {
2935       {
2936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
2937       };
2938     } catch (...) {
2939       {
2940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
2941       };
2942     }
2943   }
2944
2945   jresult = (void *)result;
2946   return jresult;
2947 }
2948
2949
2950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_doublep(void * jarg1) {
2951   doublep *arg1 = (doublep *) 0 ;
2952
2953   arg1 = (doublep *)jarg1;
2954   {
2955     try {
2956       delete_doublep(arg1);
2957     } catch (std::out_of_range& e) {
2958       {
2959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2960       };
2961     } catch (std::exception& e) {
2962       {
2963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2964       };
2965     } catch (Dali::DaliException e) {
2966       {
2967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2968       };
2969     } catch (...) {
2970       {
2971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
2972       };
2973     }
2974   }
2975
2976 }
2977
2978
2979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_doublep_assign(void * jarg1, double jarg2) {
2980   doublep *arg1 = (doublep *) 0 ;
2981   double arg2 ;
2982
2983   arg1 = (doublep *)jarg1;
2984   arg2 = (double)jarg2;
2985   {
2986     try {
2987       doublep_assign(arg1,arg2);
2988     } catch (std::out_of_range& e) {
2989       {
2990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
2991       };
2992     } catch (std::exception& e) {
2993       {
2994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
2995       };
2996     } catch (Dali::DaliException e) {
2997       {
2998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
2999       };
3000     } catch (...) {
3001       {
3002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3003       };
3004     }
3005   }
3006
3007 }
3008
3009
3010 SWIGEXPORT double SWIGSTDCALL CSharp_Dali_doublep_value(void * jarg1) {
3011   double jresult ;
3012   doublep *arg1 = (doublep *) 0 ;
3013   double result;
3014
3015   arg1 = (doublep *)jarg1;
3016   {
3017     try {
3018       result = (double)doublep_value(arg1);
3019     } catch (std::out_of_range& e) {
3020       {
3021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3022       };
3023     } catch (std::exception& e) {
3024       {
3025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3026       };
3027     } catch (Dali::DaliException e) {
3028       {
3029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3030       };
3031     } catch (...) {
3032       {
3033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3034       };
3035     }
3036   }
3037
3038   jresult = result;
3039   return jresult;
3040 }
3041
3042
3043 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_cast(void * jarg1) {
3044   void * jresult ;
3045   doublep *arg1 = (doublep *) 0 ;
3046   double *result = 0 ;
3047
3048   arg1 = (doublep *)jarg1;
3049   {
3050     try {
3051       result = (double *)doublep_cast(arg1);
3052     } catch (std::out_of_range& e) {
3053       {
3054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3055       };
3056     } catch (std::exception& e) {
3057       {
3058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3059       };
3060     } catch (Dali::DaliException e) {
3061       {
3062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3063       };
3064     } catch (...) {
3065       {
3066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3067       };
3068     }
3069   }
3070
3071   jresult = (void *)result;
3072   return jresult;
3073 }
3074
3075
3076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_doublep_frompointer(void * jarg1) {
3077   void * jresult ;
3078   double *arg1 = (double *) 0 ;
3079   doublep *result = 0 ;
3080
3081   arg1 = (double *)jarg1;
3082   {
3083     try {
3084       result = (doublep *)doublep_frompointer(arg1);
3085     } catch (std::out_of_range& e) {
3086       {
3087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3088       };
3089     } catch (std::exception& e) {
3090       {
3091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3092       };
3093     } catch (Dali::DaliException e) {
3094       {
3095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3096       };
3097     } catch (...) {
3098       {
3099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3100       };
3101     }
3102   }
3103
3104   jresult = (void *)result;
3105   return jresult;
3106 }
3107
3108
3109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_uintp() {
3110   void * jresult ;
3111   uintp *result = 0 ;
3112
3113   {
3114     try {
3115       result = (uintp *)new_uintp();
3116     } catch (std::out_of_range& e) {
3117       {
3118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3119       };
3120     } catch (std::exception& e) {
3121       {
3122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3123       };
3124     } catch (Dali::DaliException e) {
3125       {
3126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3127       };
3128     } catch (...) {
3129       {
3130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3131       };
3132     }
3133   }
3134
3135   jresult = (void *)result;
3136   return jresult;
3137 }
3138
3139
3140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_uintp(void * jarg1) {
3141   uintp *arg1 = (uintp *) 0 ;
3142
3143   arg1 = (uintp *)jarg1;
3144   {
3145     try {
3146       delete_uintp(arg1);
3147     } catch (std::out_of_range& e) {
3148       {
3149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3150       };
3151     } catch (std::exception& e) {
3152       {
3153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3154       };
3155     } catch (Dali::DaliException e) {
3156       {
3157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3158       };
3159     } catch (...) {
3160       {
3161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3162       };
3163     }
3164   }
3165
3166 }
3167
3168
3169 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_uintp_assign(void * jarg1, unsigned int jarg2) {
3170   uintp *arg1 = (uintp *) 0 ;
3171   unsigned int arg2 ;
3172
3173   arg1 = (uintp *)jarg1;
3174   arg2 = (unsigned int)jarg2;
3175   {
3176     try {
3177       uintp_assign(arg1,arg2);
3178     } catch (std::out_of_range& e) {
3179       {
3180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3181       };
3182     } catch (std::exception& e) {
3183       {
3184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3185       };
3186     } catch (Dali::DaliException e) {
3187       {
3188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3189       };
3190     } catch (...) {
3191       {
3192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3193       };
3194     }
3195   }
3196
3197 }
3198
3199
3200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_uintp_value(void * jarg1) {
3201   unsigned int jresult ;
3202   uintp *arg1 = (uintp *) 0 ;
3203   unsigned int result;
3204
3205   arg1 = (uintp *)jarg1;
3206   {
3207     try {
3208       result = (unsigned int)uintp_value(arg1);
3209     } catch (std::out_of_range& e) {
3210       {
3211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3212       };
3213     } catch (std::exception& e) {
3214       {
3215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3216       };
3217     } catch (Dali::DaliException e) {
3218       {
3219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3220       };
3221     } catch (...) {
3222       {
3223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3224       };
3225     }
3226   }
3227
3228   jresult = result;
3229   return jresult;
3230 }
3231
3232
3233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_cast(void * jarg1) {
3234   void * jresult ;
3235   uintp *arg1 = (uintp *) 0 ;
3236   unsigned int *result = 0 ;
3237
3238   arg1 = (uintp *)jarg1;
3239   {
3240     try {
3241       result = (unsigned int *)uintp_cast(arg1);
3242     } catch (std::out_of_range& e) {
3243       {
3244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3245       };
3246     } catch (std::exception& e) {
3247       {
3248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3249       };
3250     } catch (Dali::DaliException e) {
3251       {
3252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3253       };
3254     } catch (...) {
3255       {
3256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3257       };
3258     }
3259   }
3260
3261   jresult = (void *)result;
3262   return jresult;
3263 }
3264
3265
3266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_uintp_frompointer(void * jarg1) {
3267   void * jresult ;
3268   unsigned int *arg1 = (unsigned int *) 0 ;
3269   uintp *result = 0 ;
3270
3271   arg1 = (unsigned int *)jarg1;
3272   {
3273     try {
3274       result = (uintp *)uintp_frompointer(arg1);
3275     } catch (std::out_of_range& e) {
3276       {
3277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3278       };
3279     } catch (std::exception& e) {
3280       {
3281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3282       };
3283     } catch (Dali::DaliException e) {
3284       {
3285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3286       };
3287     } catch (...) {
3288       {
3289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3290       };
3291     }
3292   }
3293
3294   jresult = (void *)result;
3295   return jresult;
3296 }
3297
3298
3299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ushortp() {
3300   void * jresult ;
3301   ushortp *result = 0 ;
3302
3303   {
3304     try {
3305       result = (ushortp *)new_ushortp();
3306     } catch (std::out_of_range& e) {
3307       {
3308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3309       };
3310     } catch (std::exception& e) {
3311       {
3312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3313       };
3314     } catch (Dali::DaliException e) {
3315       {
3316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3317       };
3318     } catch (...) {
3319       {
3320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3321       };
3322     }
3323   }
3324
3325   jresult = (void *)result;
3326   return jresult;
3327 }
3328
3329
3330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ushortp(void * jarg1) {
3331   ushortp *arg1 = (ushortp *) 0 ;
3332
3333   arg1 = (ushortp *)jarg1;
3334   {
3335     try {
3336       delete_ushortp(arg1);
3337     } catch (std::out_of_range& e) {
3338       {
3339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3340       };
3341     } catch (std::exception& e) {
3342       {
3343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3344       };
3345     } catch (Dali::DaliException e) {
3346       {
3347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3348       };
3349     } catch (...) {
3350       {
3351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3352       };
3353     }
3354   }
3355
3356 }
3357
3358
3359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ushortp_assign(void * jarg1, unsigned short jarg2) {
3360   ushortp *arg1 = (ushortp *) 0 ;
3361   unsigned short arg2 ;
3362
3363   arg1 = (ushortp *)jarg1;
3364   arg2 = (unsigned short)jarg2;
3365   {
3366     try {
3367       ushortp_assign(arg1,arg2);
3368     } catch (std::out_of_range& e) {
3369       {
3370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3371       };
3372     } catch (std::exception& e) {
3373       {
3374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3375       };
3376     } catch (Dali::DaliException e) {
3377       {
3378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3379       };
3380     } catch (...) {
3381       {
3382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3383       };
3384     }
3385   }
3386
3387 }
3388
3389
3390 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_ushortp_value(void * jarg1) {
3391   unsigned short jresult ;
3392   ushortp *arg1 = (ushortp *) 0 ;
3393   unsigned short result;
3394
3395   arg1 = (ushortp *)jarg1;
3396   {
3397     try {
3398       result = (unsigned short)ushortp_value(arg1);
3399     } catch (std::out_of_range& e) {
3400       {
3401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3402       };
3403     } catch (std::exception& e) {
3404       {
3405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3406       };
3407     } catch (Dali::DaliException e) {
3408       {
3409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3410       };
3411     } catch (...) {
3412       {
3413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3414       };
3415     }
3416   }
3417
3418   jresult = result;
3419   return jresult;
3420 }
3421
3422
3423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_cast(void * jarg1) {
3424   void * jresult ;
3425   ushortp *arg1 = (ushortp *) 0 ;
3426   unsigned short *result = 0 ;
3427
3428   arg1 = (ushortp *)jarg1;
3429   {
3430     try {
3431       result = (unsigned short *)ushortp_cast(arg1);
3432     } catch (std::out_of_range& e) {
3433       {
3434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3435       };
3436     } catch (std::exception& e) {
3437       {
3438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3439       };
3440     } catch (Dali::DaliException e) {
3441       {
3442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3443       };
3444     } catch (...) {
3445       {
3446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3447       };
3448     }
3449   }
3450
3451   jresult = (void *)result;
3452   return jresult;
3453 }
3454
3455
3456 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ushortp_frompointer(void * jarg1) {
3457   void * jresult ;
3458   unsigned short *arg1 = (unsigned short *) 0 ;
3459   ushortp *result = 0 ;
3460
3461   arg1 = (unsigned short *)jarg1;
3462   {
3463     try {
3464       result = (ushortp *)ushortp_frompointer(arg1);
3465     } catch (std::out_of_range& e) {
3466       {
3467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3468       };
3469     } catch (std::exception& e) {
3470       {
3471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3472       };
3473     } catch (Dali::DaliException e) {
3474       {
3475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3476       };
3477     } catch (...) {
3478       {
3479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3480       };
3481     }
3482   }
3483
3484   jresult = (void *)result;
3485   return jresult;
3486 }
3487
3488
3489 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_int_to_uint(int jarg1) {
3490   unsigned int jresult ;
3491   int arg1 ;
3492   unsigned int result;
3493
3494   arg1 = (int)jarg1;
3495   {
3496     try {
3497       result = (unsigned int)int_to_uint(arg1);
3498     } catch (std::out_of_range& e) {
3499       {
3500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3501       };
3502     } catch (std::exception& e) {
3503       {
3504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3505       };
3506     } catch (Dali::DaliException e) {
3507       {
3508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3509       };
3510     } catch (...) {
3511       {
3512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3513       };
3514     }
3515   }
3516
3517   jresult = result;
3518   return jresult;
3519 }
3520
3521
3522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Reference(void * jarg1) {
3523   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3524
3525   arg1 = (Dali::RefObject *)jarg1;
3526   {
3527     try {
3528       (arg1)->Reference();
3529     } catch (std::out_of_range& e) {
3530       {
3531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3532       };
3533     } catch (std::exception& e) {
3534       {
3535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3536       };
3537     } catch (Dali::DaliException e) {
3538       {
3539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3540       };
3541     } catch (...) {
3542       {
3543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3544       };
3545     }
3546   }
3547
3548 }
3549
3550
3551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RefObject_Unreference(void * jarg1) {
3552   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3553
3554   arg1 = (Dali::RefObject *)jarg1;
3555   {
3556     try {
3557       (arg1)->Unreference();
3558     } catch (std::out_of_range& e) {
3559       {
3560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3561       };
3562     } catch (std::exception& e) {
3563       {
3564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3565       };
3566     } catch (Dali::DaliException e) {
3567       {
3568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3569       };
3570     } catch (...) {
3571       {
3572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3573       };
3574     }
3575   }
3576
3577 }
3578
3579
3580 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RefObject_ReferenceCount(void * jarg1) {
3581   int jresult ;
3582   Dali::RefObject *arg1 = (Dali::RefObject *) 0 ;
3583   int result;
3584
3585   arg1 = (Dali::RefObject *)jarg1;
3586   {
3587     try {
3588       result = (int)(arg1)->ReferenceCount();
3589     } catch (std::out_of_range& e) {
3590       {
3591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3592       };
3593     } catch (std::exception& e) {
3594       {
3595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3596       };
3597     } catch (Dali::DaliException e) {
3598       {
3599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3600       };
3601     } catch (...) {
3602       {
3603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3604       };
3605     }
3606   }
3607
3608   jresult = result;
3609   return jresult;
3610 }
3611
3612
3613 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_0() {
3614   void * jresult ;
3615   Dali::Any *result = 0 ;
3616
3617   {
3618     try {
3619       result = (Dali::Any *)new Dali::Any();
3620     } catch (std::out_of_range& e) {
3621       {
3622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3623       };
3624     } catch (std::exception& e) {
3625       {
3626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3627       };
3628     } catch (Dali::DaliException e) {
3629       {
3630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3631       };
3632     } catch (...) {
3633       {
3634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3635       };
3636     }
3637   }
3638
3639   jresult = (void *)result;
3640   return jresult;
3641 }
3642
3643
3644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any(void * jarg1) {
3645   Dali::Any *arg1 = (Dali::Any *) 0 ;
3646
3647   arg1 = (Dali::Any *)jarg1;
3648   {
3649     try {
3650       delete arg1;
3651     } catch (std::out_of_range& e) {
3652       {
3653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3654       };
3655     } catch (std::exception& e) {
3656       {
3657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3658       };
3659     } catch (Dali::DaliException e) {
3660       {
3661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3662       };
3663     } catch (...) {
3664       {
3665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3666       };
3667     }
3668   }
3669
3670 }
3671
3672
3673 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AssertAlways(char * jarg1) {
3674   char *arg1 = (char *) 0 ;
3675
3676   arg1 = (char *)jarg1;
3677   {
3678     try {
3679       Dali::Any::AssertAlways((char const *)arg1);
3680     } catch (std::out_of_range& e) {
3681       {
3682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3683       };
3684     } catch (std::exception& e) {
3685       {
3686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3687       };
3688     } catch (Dali::DaliException e) {
3689       {
3690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3691       };
3692     } catch (...) {
3693       {
3694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3695       };
3696     }
3697   }
3698
3699 }
3700
3701
3702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any__SWIG_2(void * jarg1) {
3703   void * jresult ;
3704   Dali::Any *arg1 = 0 ;
3705   Dali::Any *result = 0 ;
3706
3707   arg1 = (Dali::Any *)jarg1;
3708   if (!arg1) {
3709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3710     return 0;
3711   }
3712   {
3713     try {
3714       result = (Dali::Any *)new Dali::Any((Dali::Any const &)*arg1);
3715     } catch (std::out_of_range& e) {
3716       {
3717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3718       };
3719     } catch (std::exception& e) {
3720       {
3721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3722       };
3723     } catch (Dali::DaliException e) {
3724       {
3725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3726       };
3727     } catch (...) {
3728       {
3729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3730       };
3731     }
3732   }
3733
3734   jresult = (void *)result;
3735   return jresult;
3736 }
3737
3738
3739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_Assign(void * jarg1, void * jarg2) {
3740   void * jresult ;
3741   Dali::Any *arg1 = (Dali::Any *) 0 ;
3742   Dali::Any *arg2 = 0 ;
3743   Dali::Any *result = 0 ;
3744
3745   arg1 = (Dali::Any *)jarg1;
3746   arg2 = (Dali::Any *)jarg2;
3747   if (!arg2) {
3748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Any const & type is null", 0);
3749     return 0;
3750   }
3751   {
3752     try {
3753       result = (Dali::Any *) &(arg1)->operator =((Dali::Any const &)*arg2);
3754     } catch (std::out_of_range& e) {
3755       {
3756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3757       };
3758     } catch (std::exception& e) {
3759       {
3760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3761       };
3762     } catch (Dali::DaliException e) {
3763       {
3764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3765       };
3766     } catch (...) {
3767       {
3768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3769       };
3770     }
3771   }
3772
3773   jresult = (void *)result;
3774   return jresult;
3775 }
3776
3777
3778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_GetType(void * jarg1) {
3779   void * jresult ;
3780   Dali::Any *arg1 = (Dali::Any *) 0 ;
3781   std::type_info *result = 0 ;
3782
3783   arg1 = (Dali::Any *)jarg1;
3784   {
3785     try {
3786       result = (std::type_info *) &((Dali::Any const *)arg1)->GetType();
3787     } catch (std::out_of_range& e) {
3788       {
3789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3790       };
3791     } catch (std::exception& e) {
3792       {
3793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3794       };
3795     } catch (Dali::DaliException e) {
3796       {
3797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3798       };
3799     } catch (...) {
3800       {
3801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3802       };
3803     }
3804   }
3805
3806   jresult = (void *)result;
3807   return jresult;
3808 }
3809
3810
3811 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Any_Empty(void * jarg1) {
3812   unsigned int jresult ;
3813   Dali::Any *arg1 = (Dali::Any *) 0 ;
3814   bool result;
3815
3816   arg1 = (Dali::Any *)jarg1;
3817   {
3818     try {
3819       result = (bool)((Dali::Any const *)arg1)->Empty();
3820     } catch (std::out_of_range& e) {
3821       {
3822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3823       };
3824     } catch (std::exception& e) {
3825       {
3826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3827       };
3828     } catch (Dali::DaliException e) {
3829       {
3830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3831       };
3832     } catch (...) {
3833       {
3834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3835       };
3836     }
3837   }
3838
3839   jresult = result;
3840   return jresult;
3841 }
3842
3843
3844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Any_AnyContainerBase(void * jarg1, void * jarg2, void * jarg3) {
3845   void * jresult ;
3846   std::type_info *arg1 = 0 ;
3847   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3848   Dali::Any::DeleteFunc arg3 = (Dali::Any::DeleteFunc) 0 ;
3849   Dali::Any::AnyContainerBase *result = 0 ;
3850
3851   arg1 = (std::type_info *)jarg1;
3852   if (!arg1) {
3853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
3854     return 0;
3855   }
3856   arg2 = (Dali::Any::CloneFunc)jarg2;
3857   arg3 = (Dali::Any::DeleteFunc)jarg3;
3858   {
3859     try {
3860       result = (Dali::Any::AnyContainerBase *)new Dali::Any::AnyContainerBase((std::type_info const &)*arg1,arg2,arg3);
3861     } catch (std::out_of_range& e) {
3862       {
3863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3864       };
3865     } catch (std::exception& e) {
3866       {
3867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3868       };
3869     } catch (Dali::DaliException e) {
3870       {
3871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3872       };
3873     } catch (...) {
3874       {
3875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3876       };
3877     }
3878   }
3879
3880   jresult = (void *)result;
3881   return jresult;
3882 }
3883
3884
3885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_GetType(void * jarg1) {
3886   void * jresult ;
3887   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3888   std::type_info *result = 0 ;
3889
3890   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3891   {
3892     try {
3893       result = (std::type_info *) &((Dali::Any::AnyContainerBase const *)arg1)->GetType();
3894     } catch (std::out_of_range& e) {
3895       {
3896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
3897       };
3898     } catch (std::exception& e) {
3899       {
3900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
3901       };
3902     } catch (Dali::DaliException e) {
3903       {
3904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
3905       };
3906     } catch (...) {
3907       {
3908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
3909       };
3910     }
3911   }
3912
3913   jresult = (void *)result;
3914   return jresult;
3915 }
3916
3917
3918 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mType_get(void * jarg1) {
3919   void * jresult ;
3920   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3921   ::std::type_info *result = 0 ;
3922
3923   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3924   result = (::std::type_info *) &(::std::type_info const &) ((arg1)->mType);
3925   jresult = (void *)result;
3926   return jresult;
3927 }
3928
3929
3930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_set(void * jarg1, void * jarg2) {
3931   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3932   Dali::Any::CloneFunc arg2 = (Dali::Any::CloneFunc) 0 ;
3933
3934   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3935   arg2 = (Dali::Any::CloneFunc)jarg2;
3936   if (arg1) (arg1)->mCloneFunc = arg2;
3937 }
3938
3939
3940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mCloneFunc_get(void * jarg1) {
3941   void * jresult ;
3942   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3943   Dali::Any::CloneFunc result;
3944
3945   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3946   result = (Dali::Any::CloneFunc) ((arg1)->mCloneFunc);
3947   jresult = (void *)result;
3948   return jresult;
3949 }
3950
3951
3952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_set(void * jarg1, void * jarg2) {
3953   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3954   Dali::Any::DeleteFunc arg2 = (Dali::Any::DeleteFunc) 0 ;
3955
3956   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3957   arg2 = (Dali::Any::DeleteFunc)jarg2;
3958   if (arg1) (arg1)->mDeleteFunc = arg2;
3959 }
3960
3961
3962 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_AnyContainerBase_mDeleteFunc_get(void * jarg1) {
3963   void * jresult ;
3964   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3965   Dali::Any::DeleteFunc result;
3966
3967   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3968   result = (Dali::Any::DeleteFunc) ((arg1)->mDeleteFunc);
3969   jresult = (void *)result;
3970   return jresult;
3971 }
3972
3973
3974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Any_AnyContainerBase(void * jarg1) {
3975   Dali::Any::AnyContainerBase *arg1 = (Dali::Any::AnyContainerBase *) 0 ;
3976
3977   arg1 = (Dali::Any::AnyContainerBase *)jarg1;
3978   {
3979     try {
3980       delete arg1;
3981     } catch (std::out_of_range& e) {
3982       {
3983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
3984       };
3985     } catch (std::exception& e) {
3986       {
3987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
3988       };
3989     } catch (Dali::DaliException e) {
3990       {
3991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
3992       };
3993     } catch (...) {
3994       {
3995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
3996       };
3997     }
3998   }
3999
4000 }
4001
4002
4003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Any_mContainer_set(void * jarg1, void * jarg2) {
4004   Dali::Any *arg1 = (Dali::Any *) 0 ;
4005   Dali::Any::AnyContainerBase *arg2 = (Dali::Any::AnyContainerBase *) 0 ;
4006
4007   arg1 = (Dali::Any *)jarg1;
4008   arg2 = (Dali::Any::AnyContainerBase *)jarg2;
4009   if (arg1) (arg1)->mContainer = arg2;
4010 }
4011
4012
4013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Any_mContainer_get(void * jarg1) {
4014   void * jresult ;
4015   Dali::Any *arg1 = (Dali::Any *) 0 ;
4016   Dali::Any::AnyContainerBase *result = 0 ;
4017
4018   arg1 = (Dali::Any *)jarg1;
4019   result = (Dali::Any::AnyContainerBase *) ((arg1)->mContainer);
4020   jresult = (void *)result;
4021   return jresult;
4022 }
4023
4024
4025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliAssertMessage(char * jarg1, char * jarg2) {
4026   char *arg1 = (char *) 0 ;
4027   char *arg2 = (char *) 0 ;
4028
4029   arg1 = (char *)jarg1;
4030   arg2 = (char *)jarg2;
4031   {
4032     try {
4033       Dali::DaliAssertMessage((char const *)arg1,(char const *)arg2);
4034     } catch (std::out_of_range& e) {
4035       {
4036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4037       };
4038     } catch (std::exception& e) {
4039       {
4040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4041       };
4042     } catch (Dali::DaliException e) {
4043       {
4044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4045       };
4046     } catch (...) {
4047       {
4048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4049       };
4050     }
4051   }
4052
4053 }
4054
4055
4056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DaliException(char * jarg1, char * jarg2) {
4057   void * jresult ;
4058   char *arg1 = (char *) 0 ;
4059   char *arg2 = (char *) 0 ;
4060   Dali::DaliException *result = 0 ;
4061
4062   arg1 = (char *)jarg1;
4063   arg2 = (char *)jarg2;
4064   {
4065     try {
4066       result = (Dali::DaliException *)new Dali::DaliException((char const *)arg1,(char const *)arg2);
4067     } catch (std::out_of_range& e) {
4068       {
4069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4070       };
4071     } catch (std::exception& e) {
4072       {
4073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4074       };
4075     } catch (Dali::DaliException e) {
4076       {
4077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4078       };
4079     } catch (...) {
4080       {
4081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4082       };
4083     }
4084   }
4085
4086   jresult = (void *)result;
4087   return jresult;
4088 }
4089
4090
4091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_location_set(void * jarg1, char * jarg2) {
4092   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4093   std::string arg2 = std::string(jarg2);
4094
4095   arg1 = (Dali::DaliException *)jarg1;
4096   {
4097     if (!arg2.empty()) {
4098       ((char *)(arg1->location))[arg2.copy((char*)(arg1->location), strlen(arg1->location)-1)] = '\0';
4099     } else {
4100       arg1->location = 0;
4101     }
4102   }
4103 }
4104
4105 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_location_get(void * jarg1) {
4106   char * jresult ;
4107   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4108   char *result = 0 ;
4109
4110   arg1 = (Dali::DaliException *)jarg1;
4111   result = (char *) ((arg1)->location);
4112   jresult = SWIG_csharp_string_callback((const char *)result);
4113   return jresult;
4114 }
4115
4116
4117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_DaliException_condition_set(void * jarg1, char * jarg2) {
4118   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4119   std::string arg2 = std::string(jarg2);
4120
4121   arg1 = (Dali::DaliException *)jarg1;
4122   {
4123     if (!arg2.empty()) {
4124       ((char *)(arg1->condition))[arg2.copy((char*)(arg1->condition), strlen(arg1->condition)-1)] = '\0';
4125     } else {
4126       arg1->condition = 0;
4127     }
4128   }
4129 }
4130
4131
4132 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_DaliException_condition_get(void * jarg1) {
4133   char * jresult ;
4134   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4135   char *result = 0 ;
4136
4137   arg1 = (Dali::DaliException *)jarg1;
4138   result = (char *) ((arg1)->condition);
4139   jresult = SWIG_csharp_string_callback((const char *)result);
4140   return jresult;
4141 }
4142
4143
4144 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DaliException(void * jarg1) {
4145   Dali::DaliException *arg1 = (Dali::DaliException *) 0 ;
4146
4147   arg1 = (Dali::DaliException *)jarg1;
4148   {
4149     try {
4150       delete arg1;
4151     } catch (std::out_of_range& e) {
4152       {
4153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
4154       };
4155     } catch (std::exception& e) {
4156       {
4157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
4158       };
4159     } catch (Dali::DaliException e) {
4160       {
4161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
4162       };
4163     } catch (...) {
4164       {
4165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
4166       };
4167     }
4168   }
4169
4170 }
4171
4172
4173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_0() {
4174   void * jresult ;
4175   Dali::Vector2 *result = 0 ;
4176
4177   {
4178     try {
4179       result = (Dali::Vector2 *)new Dali::Vector2();
4180     } catch (std::out_of_range& e) {
4181       {
4182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4183       };
4184     } catch (std::exception& e) {
4185       {
4186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4187       };
4188     } catch (Dali::DaliException e) {
4189       {
4190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4191       };
4192     } catch (...) {
4193       {
4194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4195       };
4196     }
4197   }
4198
4199   jresult = (void *)result;
4200   return jresult;
4201 }
4202
4203
4204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_1(float jarg1, float jarg2) {
4205   void * jresult ;
4206   float arg1 ;
4207   float arg2 ;
4208   Dali::Vector2 *result = 0 ;
4209
4210   arg1 = (float)jarg1;
4211   arg2 = (float)jarg2;
4212   {
4213     try {
4214       result = (Dali::Vector2 *)new Dali::Vector2(arg1,arg2);
4215     } catch (std::out_of_range& e) {
4216       {
4217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4218       };
4219     } catch (std::exception& e) {
4220       {
4221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4222       };
4223     } catch (Dali::DaliException e) {
4224       {
4225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4226       };
4227     } catch (...) {
4228       {
4229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4230       };
4231     }
4232   }
4233
4234   jresult = (void *)result;
4235   return jresult;
4236 }
4237
4238
4239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_2(float* jarg1) {
4240   void * jresult ;
4241   float *arg1 = (float *) 0 ;
4242   Dali::Vector2 *result = 0 ;
4243
4244   arg1 = jarg1;
4245   {
4246     try {
4247       result = (Dali::Vector2 *)new Dali::Vector2((float const *)arg1);
4248     } catch (std::out_of_range& e) {
4249       {
4250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4251       };
4252     } catch (std::exception& e) {
4253       {
4254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4255       };
4256     } catch (Dali::DaliException e) {
4257       {
4258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4259       };
4260     } catch (...) {
4261       {
4262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4263       };
4264     }
4265   }
4266
4267   jresult = (void *)result;
4268
4269
4270   return jresult;
4271 }
4272
4273
4274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_3(void * jarg1) {
4275   void * jresult ;
4276   Dali::Vector3 *arg1 = 0 ;
4277   Dali::Vector2 *result = 0 ;
4278
4279   arg1 = (Dali::Vector3 *)jarg1;
4280   if (!arg1) {
4281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4282     return 0;
4283   }
4284   {
4285     try {
4286       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector3 const &)*arg1);
4287     } catch (std::out_of_range& e) {
4288       {
4289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4290       };
4291     } catch (std::exception& e) {
4292       {
4293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4294       };
4295     } catch (Dali::DaliException e) {
4296       {
4297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4298       };
4299     } catch (...) {
4300       {
4301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4302       };
4303     }
4304   }
4305
4306   jresult = (void *)result;
4307   return jresult;
4308 }
4309
4310
4311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector2__SWIG_4(void * jarg1) {
4312   void * jresult ;
4313   Dali::Vector4 *arg1 = 0 ;
4314   Dali::Vector2 *result = 0 ;
4315
4316   arg1 = (Dali::Vector4 *)jarg1;
4317   if (!arg1) {
4318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4319     return 0;
4320   }
4321   {
4322     try {
4323       result = (Dali::Vector2 *)new Dali::Vector2((Dali::Vector4 const &)*arg1);
4324     } catch (std::out_of_range& e) {
4325       {
4326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4327       };
4328     } catch (std::exception& e) {
4329       {
4330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4331       };
4332     } catch (Dali::DaliException e) {
4333       {
4334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4335       };
4336     } catch (...) {
4337       {
4338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4339       };
4340     }
4341   }
4342
4343   jresult = (void *)result;
4344   return jresult;
4345 }
4346
4347
4348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ONE_get() {
4349   void * jresult ;
4350   Dali::Vector2 *result = 0 ;
4351
4352   result = (Dali::Vector2 *)&Dali::Vector2::ONE;
4353   jresult = (void *)result;
4354   return jresult;
4355 }
4356
4357
4358 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_XAXIS_get() {
4359   void * jresult ;
4360   Dali::Vector2 *result = 0 ;
4361
4362   result = (Dali::Vector2 *)&Dali::Vector2::XAXIS;
4363   jresult = (void *)result;
4364   return jresult;
4365 }
4366
4367
4368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_YAXIS_get() {
4369   void * jresult ;
4370   Dali::Vector2 *result = 0 ;
4371
4372   result = (Dali::Vector2 *)&Dali::Vector2::YAXIS;
4373   jresult = (void *)result;
4374   return jresult;
4375 }
4376
4377
4378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_XAXIS_get() {
4379   void * jresult ;
4380   Dali::Vector2 *result = 0 ;
4381
4382   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_XAXIS;
4383   jresult = (void *)result;
4384   return jresult;
4385 }
4386
4387
4388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_NEGATIVE_YAXIS_get() {
4389   void * jresult ;
4390   Dali::Vector2 *result = 0 ;
4391
4392   result = (Dali::Vector2 *)&Dali::Vector2::NEGATIVE_YAXIS;
4393   jresult = (void *)result;
4394   return jresult;
4395 }
4396
4397
4398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_ZERO_get() {
4399   void * jresult ;
4400   Dali::Vector2 *result = 0 ;
4401
4402   result = (Dali::Vector2 *)&Dali::Vector2::ZERO;
4403   jresult = (void *)result;
4404   return jresult;
4405 }
4406
4407
4408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_0(void * jarg1, float* jarg2) {
4409   void * jresult ;
4410   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4411   float *arg2 = (float *) 0 ;
4412   Dali::Vector2 *result = 0 ;
4413
4414   arg1 = (Dali::Vector2 *)jarg1;
4415   arg2 = jarg2;
4416   {
4417     try {
4418       result = (Dali::Vector2 *) &(arg1)->operator =((float const *)arg2);
4419     } catch (std::out_of_range& e) {
4420       {
4421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4422       };
4423     } catch (std::exception& e) {
4424       {
4425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4426       };
4427     } catch (Dali::DaliException e) {
4428       {
4429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4430       };
4431     } catch (...) {
4432       {
4433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4434       };
4435     }
4436   }
4437
4438   jresult = (void *)result;
4439
4440
4441   return jresult;
4442 }
4443
4444
4445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_1(void * jarg1, void * jarg2) {
4446   void * jresult ;
4447   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4448   Dali::Vector3 *arg2 = 0 ;
4449   Dali::Vector2 *result = 0 ;
4450
4451   arg1 = (Dali::Vector2 *)jarg1;
4452   arg2 = (Dali::Vector3 *)jarg2;
4453   if (!arg2) {
4454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
4455     return 0;
4456   }
4457   {
4458     try {
4459       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
4460     } catch (std::out_of_range& e) {
4461       {
4462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4463       };
4464     } catch (std::exception& e) {
4465       {
4466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4467       };
4468     } catch (Dali::DaliException e) {
4469       {
4470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4471       };
4472     } catch (...) {
4473       {
4474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4475       };
4476     }
4477   }
4478
4479   jresult = (void *)result;
4480   return jresult;
4481 }
4482
4483
4484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Assign__SWIG_2(void * jarg1, void * jarg2) {
4485   void * jresult ;
4486   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4487   Dali::Vector4 *arg2 = 0 ;
4488   Dali::Vector2 *result = 0 ;
4489
4490   arg1 = (Dali::Vector2 *)jarg1;
4491   arg2 = (Dali::Vector4 *)jarg2;
4492   if (!arg2) {
4493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
4494     return 0;
4495   }
4496   {
4497     try {
4498       result = (Dali::Vector2 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
4499     } catch (std::out_of_range& e) {
4500       {
4501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4502       };
4503     } catch (std::exception& e) {
4504       {
4505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4506       };
4507     } catch (Dali::DaliException e) {
4508       {
4509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4510       };
4511     } catch (...) {
4512       {
4513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4514       };
4515     }
4516   }
4517
4518   jresult = (void *)result;
4519   return jresult;
4520 }
4521
4522
4523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Add(void * jarg1, void * jarg2) {
4524   void * jresult ;
4525   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4526   Dali::Vector2 *arg2 = 0 ;
4527   Dali::Vector2 result;
4528
4529   arg1 = (Dali::Vector2 *)jarg1;
4530   arg2 = (Dali::Vector2 *)jarg2;
4531   if (!arg2) {
4532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4533     return 0;
4534   }
4535   {
4536     try {
4537       result = ((Dali::Vector2 const *)arg1)->operator +((Dali::Vector2 const &)*arg2);
4538     } catch (std::out_of_range& e) {
4539       {
4540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4541       };
4542     } catch (std::exception& e) {
4543       {
4544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4545       };
4546     } catch (Dali::DaliException e) {
4547       {
4548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4549       };
4550     } catch (...) {
4551       {
4552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4553       };
4554     }
4555   }
4556
4557   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4558   return jresult;
4559 }
4560
4561
4562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AddAssign(void * jarg1, void * jarg2) {
4563   void * jresult ;
4564   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4565   Dali::Vector2 *arg2 = 0 ;
4566   Dali::Vector2 *result = 0 ;
4567
4568   arg1 = (Dali::Vector2 *)jarg1;
4569   arg2 = (Dali::Vector2 *)jarg2;
4570   if (!arg2) {
4571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4572     return 0;
4573   }
4574   {
4575     try {
4576       result = (Dali::Vector2 *) &(arg1)->operator +=((Dali::Vector2 const &)*arg2);
4577     } catch (std::out_of_range& e) {
4578       {
4579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4580       };
4581     } catch (std::exception& e) {
4582       {
4583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4584       };
4585     } catch (Dali::DaliException e) {
4586       {
4587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4588       };
4589     } catch (...) {
4590       {
4591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4592       };
4593     }
4594   }
4595
4596   jresult = (void *)result;
4597   return jresult;
4598 }
4599
4600
4601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_0(void * jarg1, void * jarg2) {
4602   void * jresult ;
4603   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4604   Dali::Vector2 *arg2 = 0 ;
4605   Dali::Vector2 result;
4606
4607   arg1 = (Dali::Vector2 *)jarg1;
4608   arg2 = (Dali::Vector2 *)jarg2;
4609   if (!arg2) {
4610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4611     return 0;
4612   }
4613   {
4614     try {
4615       result = ((Dali::Vector2 const *)arg1)->operator -((Dali::Vector2 const &)*arg2);
4616     } catch (std::out_of_range& e) {
4617       {
4618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4619       };
4620     } catch (std::exception& e) {
4621       {
4622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4623       };
4624     } catch (Dali::DaliException e) {
4625       {
4626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4627       };
4628     } catch (...) {
4629       {
4630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4631       };
4632     }
4633   }
4634
4635   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4636   return jresult;
4637 }
4638
4639
4640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_SubtractAssign(void * jarg1, void * jarg2) {
4641   void * jresult ;
4642   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4643   Dali::Vector2 *arg2 = 0 ;
4644   Dali::Vector2 *result = 0 ;
4645
4646   arg1 = (Dali::Vector2 *)jarg1;
4647   arg2 = (Dali::Vector2 *)jarg2;
4648   if (!arg2) {
4649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4650     return 0;
4651   }
4652   {
4653     try {
4654       result = (Dali::Vector2 *) &(arg1)->operator -=((Dali::Vector2 const &)*arg2);
4655     } catch (std::out_of_range& e) {
4656       {
4657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4658       };
4659     } catch (std::exception& e) {
4660       {
4661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4662       };
4663     } catch (Dali::DaliException e) {
4664       {
4665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4666       };
4667     } catch (...) {
4668       {
4669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4670       };
4671     }
4672   }
4673
4674   jresult = (void *)result;
4675   return jresult;
4676 }
4677
4678
4679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_0(void * jarg1, void * jarg2) {
4680   void * jresult ;
4681   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4682   Dali::Vector2 *arg2 = 0 ;
4683   Dali::Vector2 result;
4684
4685   arg1 = (Dali::Vector2 *)jarg1;
4686   arg2 = (Dali::Vector2 *)jarg2;
4687   if (!arg2) {
4688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4689     return 0;
4690   }
4691   {
4692     try {
4693       result = ((Dali::Vector2 const *)arg1)->operator *((Dali::Vector2 const &)*arg2);
4694     } catch (std::out_of_range& e) {
4695       {
4696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4697       };
4698     } catch (std::exception& e) {
4699       {
4700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4701       };
4702     } catch (Dali::DaliException e) {
4703       {
4704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4705       };
4706     } catch (...) {
4707       {
4708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4709       };
4710     }
4711   }
4712
4713   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4714   return jresult;
4715 }
4716
4717
4718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Multiply__SWIG_1(void * jarg1, float jarg2) {
4719   void * jresult ;
4720   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4721   float arg2 ;
4722   Dali::Vector2 result;
4723
4724   arg1 = (Dali::Vector2 *)jarg1;
4725   arg2 = (float)jarg2;
4726   {
4727     try {
4728       result = ((Dali::Vector2 const *)arg1)->operator *(arg2);
4729     } catch (std::out_of_range& e) {
4730       {
4731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4732       };
4733     } catch (std::exception& e) {
4734       {
4735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4736       };
4737     } catch (Dali::DaliException e) {
4738       {
4739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4740       };
4741     } catch (...) {
4742       {
4743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4744       };
4745     }
4746   }
4747
4748   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4749   return jresult;
4750 }
4751
4752
4753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
4754   void * jresult ;
4755   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4756   Dali::Vector2 *arg2 = 0 ;
4757   Dali::Vector2 *result = 0 ;
4758
4759   arg1 = (Dali::Vector2 *)jarg1;
4760   arg2 = (Dali::Vector2 *)jarg2;
4761   if (!arg2) {
4762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4763     return 0;
4764   }
4765   {
4766     try {
4767       result = (Dali::Vector2 *) &(arg1)->operator *=((Dali::Vector2 const &)*arg2);
4768     } catch (std::out_of_range& e) {
4769       {
4770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4771       };
4772     } catch (std::exception& e) {
4773       {
4774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4775       };
4776     } catch (Dali::DaliException e) {
4777       {
4778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4779       };
4780     } catch (...) {
4781       {
4782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4783       };
4784     }
4785   }
4786
4787   jresult = (void *)result;
4788   return jresult;
4789 }
4790
4791
4792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
4793   void * jresult ;
4794   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4795   float arg2 ;
4796   Dali::Vector2 *result = 0 ;
4797
4798   arg1 = (Dali::Vector2 *)jarg1;
4799   arg2 = (float)jarg2;
4800   {
4801     try {
4802       result = (Dali::Vector2 *) &(arg1)->operator *=(arg2);
4803     } catch (std::out_of_range& e) {
4804       {
4805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4806       };
4807     } catch (std::exception& e) {
4808       {
4809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4810       };
4811     } catch (Dali::DaliException e) {
4812       {
4813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4814       };
4815     } catch (...) {
4816       {
4817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4818       };
4819     }
4820   }
4821
4822   jresult = (void *)result;
4823   return jresult;
4824 }
4825
4826
4827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_0(void * jarg1, void * jarg2) {
4828   void * jresult ;
4829   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4830   Dali::Vector2 *arg2 = 0 ;
4831   Dali::Vector2 result;
4832
4833   arg1 = (Dali::Vector2 *)jarg1;
4834   arg2 = (Dali::Vector2 *)jarg2;
4835   if (!arg2) {
4836     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4837     return 0;
4838   }
4839   {
4840     try {
4841       result = ((Dali::Vector2 const *)arg1)->operator /((Dali::Vector2 const &)*arg2);
4842     } catch (std::out_of_range& e) {
4843       {
4844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4845       };
4846     } catch (std::exception& e) {
4847       {
4848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4849       };
4850     } catch (Dali::DaliException e) {
4851       {
4852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4853       };
4854     } catch (...) {
4855       {
4856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4857       };
4858     }
4859   }
4860
4861   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4862   return jresult;
4863 }
4864
4865
4866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Divide__SWIG_1(void * jarg1, float jarg2) {
4867   void * jresult ;
4868   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4869   float arg2 ;
4870   Dali::Vector2 result;
4871
4872   arg1 = (Dali::Vector2 *)jarg1;
4873   arg2 = (float)jarg2;
4874   {
4875     try {
4876       result = ((Dali::Vector2 const *)arg1)->operator /(arg2);
4877     } catch (std::out_of_range& e) {
4878       {
4879         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4880       };
4881     } catch (std::exception& e) {
4882       {
4883         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4884       };
4885     } catch (Dali::DaliException e) {
4886       {
4887         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4888       };
4889     } catch (...) {
4890       {
4891         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4892       };
4893     }
4894   }
4895
4896   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
4897   return jresult;
4898 }
4899
4900
4901 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
4902   void * jresult ;
4903   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4904   Dali::Vector2 *arg2 = 0 ;
4905   Dali::Vector2 *result = 0 ;
4906
4907   arg1 = (Dali::Vector2 *)jarg1;
4908   arg2 = (Dali::Vector2 *)jarg2;
4909   if (!arg2) {
4910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
4911     return 0;
4912   }
4913   {
4914     try {
4915       result = (Dali::Vector2 *) &(arg1)->operator /=((Dali::Vector2 const &)*arg2);
4916     } catch (std::out_of_range& e) {
4917       {
4918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4919       };
4920     } catch (std::exception& e) {
4921       {
4922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4923       };
4924     } catch (Dali::DaliException e) {
4925       {
4926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4927       };
4928     } catch (...) {
4929       {
4930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4931       };
4932     }
4933   }
4934
4935   jresult = (void *)result;
4936   return jresult;
4937 }
4938
4939
4940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
4941   void * jresult ;
4942   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4943   float arg2 ;
4944   Dali::Vector2 *result = 0 ;
4945
4946   arg1 = (Dali::Vector2 *)jarg1;
4947   arg2 = (float)jarg2;
4948   {
4949     try {
4950       result = (Dali::Vector2 *) &(arg1)->operator /=(arg2);
4951     } catch (std::out_of_range& e) {
4952       {
4953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4954       };
4955     } catch (std::exception& e) {
4956       {
4957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4958       };
4959     } catch (Dali::DaliException e) {
4960       {
4961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4962       };
4963     } catch (...) {
4964       {
4965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4966       };
4967     }
4968   }
4969
4970   jresult = (void *)result;
4971   return jresult;
4972 }
4973
4974
4975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_Subtract__SWIG_1(void * jarg1) {
4976   void * jresult ;
4977   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
4978   Dali::Vector2 result;
4979
4980   arg1 = (Dali::Vector2 *)jarg1;
4981   {
4982     try {
4983       result = ((Dali::Vector2 const *)arg1)->operator -();
4984     } catch (std::out_of_range& e) {
4985       {
4986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
4987       };
4988     } catch (std::exception& e) {
4989       {
4990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
4991       };
4992     } catch (Dali::DaliException e) {
4993       {
4994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
4995       };
4996     } catch (...) {
4997       {
4998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
4999       };
5000     }
5001   }
5002
5003   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5004   return jresult;
5005 }
5006
5007
5008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_EqualTo(void * jarg1, void * jarg2) {
5009   unsigned int jresult ;
5010   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5011   Dali::Vector2 *arg2 = 0 ;
5012   bool result;
5013
5014   arg1 = (Dali::Vector2 *)jarg1;
5015   arg2 = (Dali::Vector2 *)jarg2;
5016   if (!arg2) {
5017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5018     return 0;
5019   }
5020   {
5021     try {
5022       result = (bool)((Dali::Vector2 const *)arg1)->operator ==((Dali::Vector2 const &)*arg2);
5023     } catch (std::out_of_range& e) {
5024       {
5025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5026       };
5027     } catch (std::exception& e) {
5028       {
5029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5030       };
5031     } catch (Dali::DaliException e) {
5032       {
5033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5034       };
5035     } catch (...) {
5036       {
5037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5038       };
5039     }
5040   }
5041
5042   jresult = result;
5043   return jresult;
5044 }
5045
5046
5047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector2_NotEqualTo(void * jarg1, void * jarg2) {
5048   unsigned int jresult ;
5049   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5050   Dali::Vector2 *arg2 = 0 ;
5051   bool result;
5052
5053   arg1 = (Dali::Vector2 *)jarg1;
5054   arg2 = (Dali::Vector2 *)jarg2;
5055   if (!arg2) {
5056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5057     return 0;
5058   }
5059   {
5060     try {
5061       result = (bool)((Dali::Vector2 const *)arg1)->operator !=((Dali::Vector2 const &)*arg2);
5062     } catch (std::out_of_range& e) {
5063       {
5064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5065       };
5066     } catch (std::exception& e) {
5067       {
5068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5069       };
5070     } catch (Dali::DaliException e) {
5071       {
5072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5073       };
5074     } catch (...) {
5075       {
5076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5077       };
5078     }
5079   }
5080
5081   jresult = result;
5082   return jresult;
5083 }
5084
5085
5086 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
5087   float jresult ;
5088   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5089   unsigned int arg2 ;
5090   float *result = 0 ;
5091
5092   arg1 = (Dali::Vector2 *)jarg1;
5093   arg2 = (unsigned int)jarg2;
5094   {
5095     try {
5096       result = (float *) &((Dali::Vector2 const *)arg1)->operator [](arg2);
5097     } catch (std::out_of_range& e) {
5098       {
5099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5100       };
5101     } catch (std::exception& e) {
5102       {
5103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5104       };
5105     } catch (Dali::DaliException e) {
5106       {
5107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5108       };
5109     } catch (...) {
5110       {
5111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5112       };
5113     }
5114   }
5115
5116   jresult = *result;
5117   return jresult;
5118 }
5119
5120
5121 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Length(void * jarg1) {
5122   float jresult ;
5123   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5124   float result;
5125
5126   arg1 = (Dali::Vector2 *)jarg1;
5127   {
5128     try {
5129       result = (float)((Dali::Vector2 const *)arg1)->Length();
5130     } catch (std::out_of_range& e) {
5131       {
5132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5133       };
5134     } catch (std::exception& e) {
5135       {
5136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5137       };
5138     } catch (Dali::DaliException e) {
5139       {
5140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5141       };
5142     } catch (...) {
5143       {
5144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5145       };
5146     }
5147   }
5148
5149   jresult = result;
5150   return jresult;
5151 }
5152
5153
5154 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_LengthSquared(void * jarg1) {
5155   float jresult ;
5156   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5157   float result;
5158
5159   arg1 = (Dali::Vector2 *)jarg1;
5160   {
5161     try {
5162       result = (float)((Dali::Vector2 const *)arg1)->LengthSquared();
5163     } catch (std::out_of_range& e) {
5164       {
5165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5166       };
5167     } catch (std::exception& e) {
5168       {
5169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5170       };
5171     } catch (Dali::DaliException e) {
5172       {
5173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5174       };
5175     } catch (...) {
5176       {
5177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5178       };
5179     }
5180   }
5181
5182   jresult = result;
5183   return jresult;
5184 }
5185
5186
5187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Normalize(void * jarg1) {
5188   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5189
5190   arg1 = (Dali::Vector2 *)jarg1;
5191   {
5192     try {
5193       (arg1)->Normalize();
5194     } catch (std::out_of_range& e) {
5195       {
5196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5197       };
5198     } catch (std::exception& e) {
5199       {
5200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5201       };
5202     } catch (Dali::DaliException e) {
5203       {
5204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5205       };
5206     } catch (...) {
5207       {
5208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5209       };
5210     }
5211   }
5212
5213 }
5214
5215
5216 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Clamp(void * jarg1, void * jarg2, void * jarg3) {
5217   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5218   Dali::Vector2 *arg2 = 0 ;
5219   Dali::Vector2 *arg3 = 0 ;
5220
5221   arg1 = (Dali::Vector2 *)jarg1;
5222   arg2 = (Dali::Vector2 *)jarg2;
5223   if (!arg2) {
5224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5225     return ;
5226   }
5227   arg3 = (Dali::Vector2 *)jarg3;
5228   if (!arg3) {
5229     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5230     return ;
5231   }
5232   {
5233     try {
5234       (arg1)->Clamp((Dali::Vector2 const &)*arg2,(Dali::Vector2 const &)*arg3);
5235     } catch (std::out_of_range& e) {
5236       {
5237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5238       };
5239     } catch (std::exception& e) {
5240       {
5241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5242       };
5243     } catch (Dali::DaliException e) {
5244       {
5245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5246       };
5247     } catch (...) {
5248       {
5249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5250       };
5251     }
5252   }
5253
5254 }
5255
5256
5257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector2_AsFloat__SWIG_0(void * jarg1) {
5258   void * jresult ;
5259   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5260   float *result = 0 ;
5261
5262   arg1 = (Dali::Vector2 *)jarg1;
5263   {
5264     try {
5265       result = (float *)((Dali::Vector2 const *)arg1)->AsFloat();
5266     } catch (std::out_of_range& e) {
5267       {
5268         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5269       };
5270     } catch (std::exception& e) {
5271       {
5272         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5273       };
5274     } catch (Dali::DaliException e) {
5275       {
5276         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5277       };
5278     } catch (...) {
5279       {
5280         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5281       };
5282     }
5283   }
5284
5285   jresult = (void *)result;
5286   return jresult;
5287 }
5288
5289
5290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_X_set(void * jarg1, float jarg2) {
5291   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5292   float arg2 ;
5293
5294   arg1 = (Dali::Vector2 *)jarg1;
5295   arg2 = (float)jarg2;
5296   if (arg1) (arg1)->x = arg2;
5297 }
5298
5299
5300 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_X_get(void * jarg1) {
5301   float jresult ;
5302   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5303   float result;
5304
5305   arg1 = (Dali::Vector2 *)jarg1;
5306   result = (float) ((arg1)->x);
5307   jresult = result;
5308   return jresult;
5309 }
5310
5311
5312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Width_set(void * jarg1, float jarg2) {
5313   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5314   float arg2 ;
5315
5316   arg1 = (Dali::Vector2 *)jarg1;
5317   arg2 = (float)jarg2;
5318   if (arg1) (arg1)->width = arg2;
5319 }
5320
5321
5322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Width_get(void * jarg1) {
5323   float jresult ;
5324   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5325   float result;
5326
5327   arg1 = (Dali::Vector2 *)jarg1;
5328   result = (float) ((arg1)->width);
5329   jresult = result;
5330   return jresult;
5331 }
5332
5333
5334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Y_set(void * jarg1, float jarg2) {
5335   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5336   float arg2 ;
5337
5338   arg1 = (Dali::Vector2 *)jarg1;
5339   arg2 = (float)jarg2;
5340   if (arg1) (arg1)->y = arg2;
5341 }
5342
5343
5344 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Y_get(void * jarg1) {
5345   float jresult ;
5346   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5347   float result;
5348
5349   arg1 = (Dali::Vector2 *)jarg1;
5350   result = (float) ((arg1)->y);
5351   jresult = result;
5352   return jresult;
5353 }
5354
5355
5356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector2_Height_set(void * jarg1, float jarg2) {
5357   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5358   float arg2 ;
5359
5360   arg1 = (Dali::Vector2 *)jarg1;
5361   arg2 = (float)jarg2;
5362   if (arg1) (arg1)->height = arg2;
5363 }
5364
5365
5366 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector2_Height_get(void * jarg1) {
5367   float jresult ;
5368   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5369   float result;
5370
5371   arg1 = (Dali::Vector2 *)jarg1;
5372   result = (float) ((arg1)->height);
5373   jresult = result;
5374   return jresult;
5375 }
5376
5377
5378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector2(void * jarg1) {
5379   Dali::Vector2 *arg1 = (Dali::Vector2 *) 0 ;
5380
5381   arg1 = (Dali::Vector2 *)jarg1;
5382   {
5383     try {
5384       delete arg1;
5385     } catch (std::out_of_range& e) {
5386       {
5387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
5388       };
5389     } catch (std::exception& e) {
5390       {
5391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
5392       };
5393     } catch (Dali::DaliException e) {
5394       {
5395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
5396       };
5397     } catch (...) {
5398       {
5399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
5400       };
5401     }
5402   }
5403
5404 }
5405
5406
5407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_0(void * jarg1, void * jarg2) {
5408   void * jresult ;
5409   Dali::Vector2 *arg1 = 0 ;
5410   Dali::Vector2 *arg2 = 0 ;
5411   Dali::Vector2 result;
5412
5413   arg1 = (Dali::Vector2 *)jarg1;
5414   if (!arg1) {
5415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5416     return 0;
5417   }
5418   arg2 = (Dali::Vector2 *)jarg2;
5419   if (!arg2) {
5420     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5421     return 0;
5422   }
5423   {
5424     try {
5425       result = Dali::Min((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5426     } catch (std::out_of_range& e) {
5427       {
5428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5429       };
5430     } catch (std::exception& e) {
5431       {
5432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5433       };
5434     } catch (Dali::DaliException e) {
5435       {
5436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5437       };
5438     } catch (...) {
5439       {
5440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5441       };
5442     }
5443   }
5444
5445   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5446   return jresult;
5447 }
5448
5449
5450 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_0(void * jarg1, void * jarg2) {
5451   void * jresult ;
5452   Dali::Vector2 *arg1 = 0 ;
5453   Dali::Vector2 *arg2 = 0 ;
5454   Dali::Vector2 result;
5455
5456   arg1 = (Dali::Vector2 *)jarg1;
5457   if (!arg1) {
5458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5459     return 0;
5460   }
5461   arg2 = (Dali::Vector2 *)jarg2;
5462   if (!arg2) {
5463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5464     return 0;
5465   }
5466   {
5467     try {
5468       result = Dali::Max((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
5469     } catch (std::out_of_range& e) {
5470       {
5471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5472       };
5473     } catch (std::exception& e) {
5474       {
5475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5476       };
5477     } catch (Dali::DaliException e) {
5478       {
5479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5480       };
5481     } catch (...) {
5482       {
5483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5484       };
5485     }
5486   }
5487
5488   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5489   return jresult;
5490 }
5491
5492
5493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3) {
5494   void * jresult ;
5495   Dali::Vector2 *arg1 = 0 ;
5496   float *arg2 = 0 ;
5497   float *arg3 = 0 ;
5498   float temp2 ;
5499   float temp3 ;
5500   Dali::Vector2 result;
5501
5502   arg1 = (Dali::Vector2 *)jarg1;
5503   if (!arg1) {
5504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5505     return 0;
5506   }
5507   temp2 = (float)jarg2;
5508   arg2 = &temp2;
5509   temp3 = (float)jarg3;
5510   arg3 = &temp3;
5511   {
5512     try {
5513       result = Dali::Clamp((Dali::Vector2 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
5514     } catch (std::out_of_range& e) {
5515       {
5516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5517       };
5518     } catch (std::exception& e) {
5519       {
5520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5521       };
5522     } catch (Dali::DaliException e) {
5523       {
5524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5525       };
5526     } catch (...) {
5527       {
5528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5529       };
5530     }
5531   }
5532
5533   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
5534   return jresult;
5535 }
5536
5537
5538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_0() {
5539   void * jresult ;
5540   Dali::Vector3 *result = 0 ;
5541
5542   {
5543     try {
5544       result = (Dali::Vector3 *)new Dali::Vector3();
5545     } catch (std::out_of_range& e) {
5546       {
5547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5548       };
5549     } catch (std::exception& e) {
5550       {
5551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5552       };
5553     } catch (Dali::DaliException e) {
5554       {
5555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5556       };
5557     } catch (...) {
5558       {
5559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5560       };
5561     }
5562   }
5563
5564   jresult = (void *)result;
5565   return jresult;
5566 }
5567
5568
5569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_1(float jarg1, float jarg2, float jarg3) {
5570   void * jresult ;
5571   float arg1 ;
5572   float arg2 ;
5573   float arg3 ;
5574   Dali::Vector3 *result = 0 ;
5575
5576   arg1 = (float)jarg1;
5577   arg2 = (float)jarg2;
5578   arg3 = (float)jarg3;
5579   {
5580     try {
5581       result = (Dali::Vector3 *)new Dali::Vector3(arg1,arg2,arg3);
5582     } catch (std::out_of_range& e) {
5583       {
5584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5585       };
5586     } catch (std::exception& e) {
5587       {
5588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5589       };
5590     } catch (Dali::DaliException e) {
5591       {
5592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5593       };
5594     } catch (...) {
5595       {
5596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5597       };
5598     }
5599   }
5600
5601   jresult = (void *)result;
5602   return jresult;
5603 }
5604
5605
5606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_2(float* jarg1) {
5607   void * jresult ;
5608   float *arg1 = (float *) 0 ;
5609   Dali::Vector3 *result = 0 ;
5610
5611   arg1 = jarg1;
5612   {
5613     try {
5614       result = (Dali::Vector3 *)new Dali::Vector3((float const *)arg1);
5615     } catch (std::out_of_range& e) {
5616       {
5617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5618       };
5619     } catch (std::exception& e) {
5620       {
5621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5622       };
5623     } catch (Dali::DaliException e) {
5624       {
5625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5626       };
5627     } catch (...) {
5628       {
5629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5630       };
5631     }
5632   }
5633
5634   jresult = (void *)result;
5635
5636
5637   return jresult;
5638 }
5639
5640
5641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_3(void * jarg1) {
5642   void * jresult ;
5643   Dali::Vector2 *arg1 = 0 ;
5644   Dali::Vector3 *result = 0 ;
5645
5646   arg1 = (Dali::Vector2 *)jarg1;
5647   if (!arg1) {
5648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5649     return 0;
5650   }
5651   {
5652     try {
5653       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector2 const &)*arg1);
5654     } catch (std::out_of_range& e) {
5655       {
5656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5657       };
5658     } catch (std::exception& e) {
5659       {
5660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5661       };
5662     } catch (Dali::DaliException e) {
5663       {
5664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5665       };
5666     } catch (...) {
5667       {
5668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5669       };
5670     }
5671   }
5672
5673   jresult = (void *)result;
5674   return jresult;
5675 }
5676
5677
5678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector3__SWIG_4(void * jarg1) {
5679   void * jresult ;
5680   Dali::Vector4 *arg1 = 0 ;
5681   Dali::Vector3 *result = 0 ;
5682
5683   arg1 = (Dali::Vector4 *)jarg1;
5684   if (!arg1) {
5685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5686     return 0;
5687   }
5688   {
5689     try {
5690       result = (Dali::Vector3 *)new Dali::Vector3((Dali::Vector4 const &)*arg1);
5691     } catch (std::out_of_range& e) {
5692       {
5693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5694       };
5695     } catch (std::exception& e) {
5696       {
5697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5698       };
5699     } catch (Dali::DaliException e) {
5700       {
5701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5702       };
5703     } catch (...) {
5704       {
5705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5706       };
5707     }
5708   }
5709
5710   jresult = (void *)result;
5711   return jresult;
5712 }
5713
5714
5715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ONE_get() {
5716   void * jresult ;
5717   Dali::Vector3 *result = 0 ;
5718
5719   result = (Dali::Vector3 *)&Dali::Vector3::ONE;
5720   jresult = (void *)result;
5721   return jresult;
5722 }
5723
5724
5725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_XAXIS_get() {
5726   void * jresult ;
5727   Dali::Vector3 *result = 0 ;
5728
5729   result = (Dali::Vector3 *)&Dali::Vector3::XAXIS;
5730   jresult = (void *)result;
5731   return jresult;
5732 }
5733
5734
5735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_YAXIS_get() {
5736   void * jresult ;
5737   Dali::Vector3 *result = 0 ;
5738
5739   result = (Dali::Vector3 *)&Dali::Vector3::YAXIS;
5740   jresult = (void *)result;
5741   return jresult;
5742 }
5743
5744
5745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZAXIS_get() {
5746   void * jresult ;
5747   Dali::Vector3 *result = 0 ;
5748
5749   result = (Dali::Vector3 *)&Dali::Vector3::ZAXIS;
5750   jresult = (void *)result;
5751   return jresult;
5752 }
5753
5754
5755 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_XAXIS_get() {
5756   void * jresult ;
5757   Dali::Vector3 *result = 0 ;
5758
5759   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_XAXIS;
5760   jresult = (void *)result;
5761   return jresult;
5762 }
5763
5764
5765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_YAXIS_get() {
5766   void * jresult ;
5767   Dali::Vector3 *result = 0 ;
5768
5769   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_YAXIS;
5770   jresult = (void *)result;
5771   return jresult;
5772 }
5773
5774
5775 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_NEGATIVE_ZAXIS_get() {
5776   void * jresult ;
5777   Dali::Vector3 *result = 0 ;
5778
5779   result = (Dali::Vector3 *)&Dali::Vector3::NEGATIVE_ZAXIS;
5780   jresult = (void *)result;
5781   return jresult;
5782 }
5783
5784
5785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_ZERO_get() {
5786   void * jresult ;
5787   Dali::Vector3 *result = 0 ;
5788
5789   result = (Dali::Vector3 *)&Dali::Vector3::ZERO;
5790   jresult = (void *)result;
5791   return jresult;
5792 }
5793
5794
5795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_0(void * jarg1, float* jarg2) {
5796   void * jresult ;
5797   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5798   float *arg2 = (float *) 0 ;
5799   Dali::Vector3 *result = 0 ;
5800
5801   arg1 = (Dali::Vector3 *)jarg1;
5802   arg2 = jarg2;
5803   {
5804     try {
5805       result = (Dali::Vector3 *) &(arg1)->operator =((float const *)arg2);
5806     } catch (std::out_of_range& e) {
5807       {
5808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5809       };
5810     } catch (std::exception& e) {
5811       {
5812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5813       };
5814     } catch (Dali::DaliException e) {
5815       {
5816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5817       };
5818     } catch (...) {
5819       {
5820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5821       };
5822     }
5823   }
5824
5825   jresult = (void *)result;
5826
5827
5828   return jresult;
5829 }
5830
5831
5832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_1(void * jarg1, void * jarg2) {
5833   void * jresult ;
5834   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5835   Dali::Vector2 *arg2 = 0 ;
5836   Dali::Vector3 *result = 0 ;
5837
5838   arg1 = (Dali::Vector3 *)jarg1;
5839   arg2 = (Dali::Vector2 *)jarg2;
5840   if (!arg2) {
5841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
5842     return 0;
5843   }
5844   {
5845     try {
5846       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
5847     } catch (std::out_of_range& e) {
5848       {
5849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5850       };
5851     } catch (std::exception& e) {
5852       {
5853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5854       };
5855     } catch (Dali::DaliException e) {
5856       {
5857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5858       };
5859     } catch (...) {
5860       {
5861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5862       };
5863     }
5864   }
5865
5866   jresult = (void *)result;
5867   return jresult;
5868 }
5869
5870
5871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Assign__SWIG_2(void * jarg1, void * jarg2) {
5872   void * jresult ;
5873   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5874   Dali::Vector4 *arg2 = 0 ;
5875   Dali::Vector3 *result = 0 ;
5876
5877   arg1 = (Dali::Vector3 *)jarg1;
5878   arg2 = (Dali::Vector4 *)jarg2;
5879   if (!arg2) {
5880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
5881     return 0;
5882   }
5883   {
5884     try {
5885       result = (Dali::Vector3 *) &(arg1)->operator =((Dali::Vector4 const &)*arg2);
5886     } catch (std::out_of_range& e) {
5887       {
5888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5889       };
5890     } catch (std::exception& e) {
5891       {
5892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5893       };
5894     } catch (Dali::DaliException e) {
5895       {
5896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5897       };
5898     } catch (...) {
5899       {
5900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5901       };
5902     }
5903   }
5904
5905   jresult = (void *)result;
5906   return jresult;
5907 }
5908
5909
5910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Add(void * jarg1, void * jarg2) {
5911   void * jresult ;
5912   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5913   Dali::Vector3 *arg2 = 0 ;
5914   Dali::Vector3 result;
5915
5916   arg1 = (Dali::Vector3 *)jarg1;
5917   arg2 = (Dali::Vector3 *)jarg2;
5918   if (!arg2) {
5919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5920     return 0;
5921   }
5922   {
5923     try {
5924       result = ((Dali::Vector3 const *)arg1)->operator +((Dali::Vector3 const &)*arg2);
5925     } catch (std::out_of_range& e) {
5926       {
5927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5928       };
5929     } catch (std::exception& e) {
5930       {
5931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5932       };
5933     } catch (Dali::DaliException e) {
5934       {
5935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5936       };
5937     } catch (...) {
5938       {
5939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5940       };
5941     }
5942   }
5943
5944   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
5945   return jresult;
5946 }
5947
5948
5949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AddAssign(void * jarg1, void * jarg2) {
5950   void * jresult ;
5951   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5952   Dali::Vector3 *arg2 = 0 ;
5953   Dali::Vector3 *result = 0 ;
5954
5955   arg1 = (Dali::Vector3 *)jarg1;
5956   arg2 = (Dali::Vector3 *)jarg2;
5957   if (!arg2) {
5958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5959     return 0;
5960   }
5961   {
5962     try {
5963       result = (Dali::Vector3 *) &(arg1)->operator +=((Dali::Vector3 const &)*arg2);
5964     } catch (std::out_of_range& e) {
5965       {
5966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
5967       };
5968     } catch (std::exception& e) {
5969       {
5970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
5971       };
5972     } catch (Dali::DaliException e) {
5973       {
5974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
5975       };
5976     } catch (...) {
5977       {
5978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
5979       };
5980     }
5981   }
5982
5983   jresult = (void *)result;
5984   return jresult;
5985 }
5986
5987
5988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_0(void * jarg1, void * jarg2) {
5989   void * jresult ;
5990   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
5991   Dali::Vector3 *arg2 = 0 ;
5992   Dali::Vector3 result;
5993
5994   arg1 = (Dali::Vector3 *)jarg1;
5995   arg2 = (Dali::Vector3 *)jarg2;
5996   if (!arg2) {
5997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
5998     return 0;
5999   }
6000   {
6001     try {
6002       result = ((Dali::Vector3 const *)arg1)->operator -((Dali::Vector3 const &)*arg2);
6003     } catch (std::out_of_range& e) {
6004       {
6005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6006       };
6007     } catch (std::exception& e) {
6008       {
6009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6010       };
6011     } catch (Dali::DaliException e) {
6012       {
6013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6014       };
6015     } catch (...) {
6016       {
6017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6018       };
6019     }
6020   }
6021
6022   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6023   return jresult;
6024 }
6025
6026
6027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_SubtractAssign(void * jarg1, void * jarg2) {
6028   void * jresult ;
6029   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6030   Dali::Vector3 *arg2 = 0 ;
6031   Dali::Vector3 *result = 0 ;
6032
6033   arg1 = (Dali::Vector3 *)jarg1;
6034   arg2 = (Dali::Vector3 *)jarg2;
6035   if (!arg2) {
6036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6037     return 0;
6038   }
6039   {
6040     try {
6041       result = (Dali::Vector3 *) &(arg1)->operator -=((Dali::Vector3 const &)*arg2);
6042     } catch (std::out_of_range& e) {
6043       {
6044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6045       };
6046     } catch (std::exception& e) {
6047       {
6048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6049       };
6050     } catch (Dali::DaliException e) {
6051       {
6052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6053       };
6054     } catch (...) {
6055       {
6056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6057       };
6058     }
6059   }
6060
6061   jresult = (void *)result;
6062   return jresult;
6063 }
6064
6065
6066 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_0(void * jarg1, void * jarg2) {
6067   void * jresult ;
6068   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6069   Dali::Vector3 *arg2 = 0 ;
6070   Dali::Vector3 result;
6071
6072   arg1 = (Dali::Vector3 *)jarg1;
6073   arg2 = (Dali::Vector3 *)jarg2;
6074   if (!arg2) {
6075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6076     return 0;
6077   }
6078   {
6079     try {
6080       result = ((Dali::Vector3 const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
6081     } catch (std::out_of_range& e) {
6082       {
6083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6084       };
6085     } catch (std::exception& e) {
6086       {
6087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6088       };
6089     } catch (Dali::DaliException e) {
6090       {
6091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6092       };
6093     } catch (...) {
6094       {
6095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6096       };
6097     }
6098   }
6099
6100   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6101   return jresult;
6102 }
6103
6104
6105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Multiply__SWIG_1(void * jarg1, float jarg2) {
6106   void * jresult ;
6107   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6108   float arg2 ;
6109   Dali::Vector3 result;
6110
6111   arg1 = (Dali::Vector3 *)jarg1;
6112   arg2 = (float)jarg2;
6113   {
6114     try {
6115       result = ((Dali::Vector3 const *)arg1)->operator *(arg2);
6116     } catch (std::out_of_range& e) {
6117       {
6118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6119       };
6120     } catch (std::exception& e) {
6121       {
6122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6123       };
6124     } catch (Dali::DaliException e) {
6125       {
6126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6127       };
6128     } catch (...) {
6129       {
6130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6131       };
6132     }
6133   }
6134
6135   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6136   return jresult;
6137 }
6138
6139
6140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
6141   void * jresult ;
6142   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6143   Dali::Vector3 *arg2 = 0 ;
6144   Dali::Vector3 *result = 0 ;
6145
6146   arg1 = (Dali::Vector3 *)jarg1;
6147   arg2 = (Dali::Vector3 *)jarg2;
6148   if (!arg2) {
6149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6150     return 0;
6151   }
6152   {
6153     try {
6154       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Vector3 const &)*arg2);
6155     } catch (std::out_of_range& e) {
6156       {
6157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6158       };
6159     } catch (std::exception& e) {
6160       {
6161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6162       };
6163     } catch (Dali::DaliException e) {
6164       {
6165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6166       };
6167     } catch (...) {
6168       {
6169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6170       };
6171     }
6172   }
6173
6174   jresult = (void *)result;
6175   return jresult;
6176 }
6177
6178
6179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
6180   void * jresult ;
6181   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6182   float arg2 ;
6183   Dali::Vector3 *result = 0 ;
6184
6185   arg1 = (Dali::Vector3 *)jarg1;
6186   arg2 = (float)jarg2;
6187   {
6188     try {
6189       result = (Dali::Vector3 *) &(arg1)->operator *=(arg2);
6190     } catch (std::out_of_range& e) {
6191       {
6192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6193       };
6194     } catch (std::exception& e) {
6195       {
6196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6197       };
6198     } catch (Dali::DaliException e) {
6199       {
6200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6201       };
6202     } catch (...) {
6203       {
6204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6205       };
6206     }
6207   }
6208
6209   jresult = (void *)result;
6210   return jresult;
6211 }
6212
6213
6214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_MultiplyAssign__SWIG_2(void * jarg1, void * jarg2) {
6215   void * jresult ;
6216   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6217   Dali::Quaternion *arg2 = 0 ;
6218   Dali::Vector3 *result = 0 ;
6219
6220   arg1 = (Dali::Vector3 *)jarg1;
6221   arg2 = (Dali::Quaternion *)jarg2;
6222   if (!arg2) {
6223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
6224     return 0;
6225   }
6226   {
6227     try {
6228       result = (Dali::Vector3 *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
6229     } catch (std::out_of_range& e) {
6230       {
6231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6232       };
6233     } catch (std::exception& e) {
6234       {
6235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6236       };
6237     } catch (Dali::DaliException e) {
6238       {
6239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6240       };
6241     } catch (...) {
6242       {
6243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6244       };
6245     }
6246   }
6247
6248   jresult = (void *)result;
6249   return jresult;
6250 }
6251
6252
6253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_0(void * jarg1, void * jarg2) {
6254   void * jresult ;
6255   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6256   Dali::Vector3 *arg2 = 0 ;
6257   Dali::Vector3 result;
6258
6259   arg1 = (Dali::Vector3 *)jarg1;
6260   arg2 = (Dali::Vector3 *)jarg2;
6261   if (!arg2) {
6262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6263     return 0;
6264   }
6265   {
6266     try {
6267       result = ((Dali::Vector3 const *)arg1)->operator /((Dali::Vector3 const &)*arg2);
6268     } catch (std::out_of_range& e) {
6269       {
6270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6271       };
6272     } catch (std::exception& e) {
6273       {
6274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6275       };
6276     } catch (Dali::DaliException e) {
6277       {
6278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6279       };
6280     } catch (...) {
6281       {
6282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6283       };
6284     }
6285   }
6286
6287   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6288   return jresult;
6289 }
6290
6291
6292 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Divide__SWIG_1(void * jarg1, float jarg2) {
6293   void * jresult ;
6294   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6295   float arg2 ;
6296   Dali::Vector3 result;
6297
6298   arg1 = (Dali::Vector3 *)jarg1;
6299   arg2 = (float)jarg2;
6300   {
6301     try {
6302       result = ((Dali::Vector3 const *)arg1)->operator /(arg2);
6303     } catch (std::out_of_range& e) {
6304       {
6305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6306       };
6307     } catch (std::exception& e) {
6308       {
6309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6310       };
6311     } catch (Dali::DaliException e) {
6312       {
6313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6314       };
6315     } catch (...) {
6316       {
6317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6318       };
6319     }
6320   }
6321
6322   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6323   return jresult;
6324 }
6325
6326
6327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
6328   void * jresult ;
6329   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6330   Dali::Vector3 *arg2 = 0 ;
6331   Dali::Vector3 *result = 0 ;
6332
6333   arg1 = (Dali::Vector3 *)jarg1;
6334   arg2 = (Dali::Vector3 *)jarg2;
6335   if (!arg2) {
6336     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6337     return 0;
6338   }
6339   {
6340     try {
6341       result = (Dali::Vector3 *) &(arg1)->operator /=((Dali::Vector3 const &)*arg2);
6342     } catch (std::out_of_range& e) {
6343       {
6344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6345       };
6346     } catch (std::exception& e) {
6347       {
6348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6349       };
6350     } catch (Dali::DaliException e) {
6351       {
6352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6353       };
6354     } catch (...) {
6355       {
6356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6357       };
6358     }
6359   }
6360
6361   jresult = (void *)result;
6362   return jresult;
6363 }
6364
6365
6366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
6367   void * jresult ;
6368   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6369   float arg2 ;
6370   Dali::Vector3 *result = 0 ;
6371
6372   arg1 = (Dali::Vector3 *)jarg1;
6373   arg2 = (float)jarg2;
6374   {
6375     try {
6376       result = (Dali::Vector3 *) &(arg1)->operator /=(arg2);
6377     } catch (std::out_of_range& e) {
6378       {
6379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6380       };
6381     } catch (std::exception& e) {
6382       {
6383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6384       };
6385     } catch (Dali::DaliException e) {
6386       {
6387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6388       };
6389     } catch (...) {
6390       {
6391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6392       };
6393     }
6394   }
6395
6396   jresult = (void *)result;
6397   return jresult;
6398 }
6399
6400
6401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Subtract__SWIG_1(void * jarg1) {
6402   void * jresult ;
6403   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6404   Dali::Vector3 result;
6405
6406   arg1 = (Dali::Vector3 *)jarg1;
6407   {
6408     try {
6409       result = ((Dali::Vector3 const *)arg1)->operator -();
6410     } catch (std::out_of_range& e) {
6411       {
6412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6413       };
6414     } catch (std::exception& e) {
6415       {
6416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6417       };
6418     } catch (Dali::DaliException e) {
6419       {
6420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6421       };
6422     } catch (...) {
6423       {
6424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6425       };
6426     }
6427   }
6428
6429   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6430   return jresult;
6431 }
6432
6433
6434 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_EqualTo(void * jarg1, void * jarg2) {
6435   unsigned int jresult ;
6436   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6437   Dali::Vector3 *arg2 = 0 ;
6438   bool result;
6439
6440   arg1 = (Dali::Vector3 *)jarg1;
6441   arg2 = (Dali::Vector3 *)jarg2;
6442   if (!arg2) {
6443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6444     return 0;
6445   }
6446   {
6447     try {
6448       result = (bool)((Dali::Vector3 const *)arg1)->operator ==((Dali::Vector3 const &)*arg2);
6449     } catch (std::out_of_range& e) {
6450       {
6451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6452       };
6453     } catch (std::exception& e) {
6454       {
6455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6456       };
6457     } catch (Dali::DaliException e) {
6458       {
6459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6460       };
6461     } catch (...) {
6462       {
6463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6464       };
6465     }
6466   }
6467
6468   jresult = result;
6469   return jresult;
6470 }
6471
6472
6473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector3_NotEqualTo(void * jarg1, void * jarg2) {
6474   unsigned int jresult ;
6475   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6476   Dali::Vector3 *arg2 = 0 ;
6477   bool result;
6478
6479   arg1 = (Dali::Vector3 *)jarg1;
6480   arg2 = (Dali::Vector3 *)jarg2;
6481   if (!arg2) {
6482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6483     return 0;
6484   }
6485   {
6486     try {
6487       result = (bool)((Dali::Vector3 const *)arg1)->operator !=((Dali::Vector3 const &)*arg2);
6488     } catch (std::out_of_range& e) {
6489       {
6490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6491       };
6492     } catch (std::exception& e) {
6493       {
6494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6495       };
6496     } catch (Dali::DaliException e) {
6497       {
6498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6499       };
6500     } catch (...) {
6501       {
6502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6503       };
6504     }
6505   }
6506
6507   jresult = result;
6508   return jresult;
6509 }
6510
6511
6512 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
6513   float jresult ;
6514   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6515   unsigned int arg2 ;
6516   float *result = 0 ;
6517
6518   arg1 = (Dali::Vector3 *)jarg1;
6519   arg2 = (unsigned int)jarg2;
6520   {
6521     try {
6522       result = (float *) &((Dali::Vector3 const *)arg1)->operator [](arg2);
6523     } catch (std::out_of_range& e) {
6524       {
6525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6526       };
6527     } catch (std::exception& e) {
6528       {
6529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6530       };
6531     } catch (Dali::DaliException e) {
6532       {
6533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6534       };
6535     } catch (...) {
6536       {
6537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6538       };
6539     }
6540   }
6541
6542   jresult = *result;
6543   return jresult;
6544 }
6545
6546
6547 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Dot(void * jarg1, void * jarg2) {
6548   float jresult ;
6549   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6550   Dali::Vector3 *arg2 = 0 ;
6551   float result;
6552
6553   arg1 = (Dali::Vector3 *)jarg1;
6554   arg2 = (Dali::Vector3 *)jarg2;
6555   if (!arg2) {
6556     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6557     return 0;
6558   }
6559   {
6560     try {
6561       result = (float)((Dali::Vector3 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
6562     } catch (std::out_of_range& e) {
6563       {
6564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6565       };
6566     } catch (std::exception& e) {
6567       {
6568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6569       };
6570     } catch (Dali::DaliException e) {
6571       {
6572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6573       };
6574     } catch (...) {
6575       {
6576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6577       };
6578     }
6579   }
6580
6581   jresult = result;
6582   return jresult;
6583 }
6584
6585
6586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_Cross(void * jarg1, void * jarg2) {
6587   void * jresult ;
6588   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6589   Dali::Vector3 *arg2 = 0 ;
6590   Dali::Vector3 result;
6591
6592   arg1 = (Dali::Vector3 *)jarg1;
6593   arg2 = (Dali::Vector3 *)jarg2;
6594   if (!arg2) {
6595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6596     return 0;
6597   }
6598   {
6599     try {
6600       result = ((Dali::Vector3 const *)arg1)->Cross((Dali::Vector3 const &)*arg2);
6601     } catch (std::out_of_range& e) {
6602       {
6603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6604       };
6605     } catch (std::exception& e) {
6606       {
6607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6608       };
6609     } catch (Dali::DaliException e) {
6610       {
6611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6612       };
6613     } catch (...) {
6614       {
6615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6616       };
6617     }
6618   }
6619
6620   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
6621   return jresult;
6622 }
6623
6624
6625 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Length(void * jarg1) {
6626   float jresult ;
6627   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6628   float result;
6629
6630   arg1 = (Dali::Vector3 *)jarg1;
6631   {
6632     try {
6633       result = (float)((Dali::Vector3 const *)arg1)->Length();
6634     } catch (std::out_of_range& e) {
6635       {
6636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6637       };
6638     } catch (std::exception& e) {
6639       {
6640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6641       };
6642     } catch (Dali::DaliException e) {
6643       {
6644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6645       };
6646     } catch (...) {
6647       {
6648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6649       };
6650     }
6651   }
6652
6653   jresult = result;
6654   return jresult;
6655 }
6656
6657
6658 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_LengthSquared(void * jarg1) {
6659   float jresult ;
6660   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6661   float result;
6662
6663   arg1 = (Dali::Vector3 *)jarg1;
6664   {
6665     try {
6666       result = (float)((Dali::Vector3 const *)arg1)->LengthSquared();
6667     } catch (std::out_of_range& e) {
6668       {
6669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6670       };
6671     } catch (std::exception& e) {
6672       {
6673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6674       };
6675     } catch (Dali::DaliException e) {
6676       {
6677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6678       };
6679     } catch (...) {
6680       {
6681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6682       };
6683     }
6684   }
6685
6686   jresult = result;
6687   return jresult;
6688 }
6689
6690
6691 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Normalize(void * jarg1) {
6692   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6693
6694   arg1 = (Dali::Vector3 *)jarg1;
6695   {
6696     try {
6697       (arg1)->Normalize();
6698     } catch (std::out_of_range& e) {
6699       {
6700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6701       };
6702     } catch (std::exception& e) {
6703       {
6704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6705       };
6706     } catch (Dali::DaliException e) {
6707       {
6708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6709       };
6710     } catch (...) {
6711       {
6712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6713       };
6714     }
6715   }
6716
6717 }
6718
6719
6720 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Clamp(void * jarg1, void * jarg2, void * jarg3) {
6721   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6722   Dali::Vector3 *arg2 = 0 ;
6723   Dali::Vector3 *arg3 = 0 ;
6724
6725   arg1 = (Dali::Vector3 *)jarg1;
6726   arg2 = (Dali::Vector3 *)jarg2;
6727   if (!arg2) {
6728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6729     return ;
6730   }
6731   arg3 = (Dali::Vector3 *)jarg3;
6732   if (!arg3) {
6733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
6734     return ;
6735   }
6736   {
6737     try {
6738       (arg1)->Clamp((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3);
6739     } catch (std::out_of_range& e) {
6740       {
6741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
6742       };
6743     } catch (std::exception& e) {
6744       {
6745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
6746       };
6747     } catch (Dali::DaliException e) {
6748       {
6749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
6750       };
6751     } catch (...) {
6752       {
6753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
6754       };
6755     }
6756   }
6757
6758 }
6759
6760
6761 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_AsFloat__SWIG_0(void * jarg1) {
6762   void * jresult ;
6763   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6764   float *result = 0 ;
6765
6766   arg1 = (Dali::Vector3 *)jarg1;
6767   {
6768     try {
6769       result = (float *)((Dali::Vector3 const *)arg1)->AsFloat();
6770     } catch (std::out_of_range& e) {
6771       {
6772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6773       };
6774     } catch (std::exception& e) {
6775       {
6776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6777       };
6778     } catch (Dali::DaliException e) {
6779       {
6780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6781       };
6782     } catch (...) {
6783       {
6784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6785       };
6786     }
6787   }
6788
6789   jresult = (void *)result;
6790   return jresult;
6791 }
6792
6793
6794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorXY__SWIG_0(void * jarg1) {
6795   void * jresult ;
6796   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6797   Dali::Vector2 *result = 0 ;
6798
6799   arg1 = (Dali::Vector3 *)jarg1;
6800   {
6801     try {
6802       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorXY();
6803     } catch (std::out_of_range& e) {
6804       {
6805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6806       };
6807     } catch (std::exception& e) {
6808       {
6809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6810       };
6811     } catch (Dali::DaliException e) {
6812       {
6813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6814       };
6815     } catch (...) {
6816       {
6817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6818       };
6819     }
6820   }
6821
6822   jresult = (void *)result;
6823   return jresult;
6824 }
6825
6826
6827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector3_GetVectorYZ__SWIG_0(void * jarg1) {
6828   void * jresult ;
6829   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6830   Dali::Vector2 *result = 0 ;
6831
6832   arg1 = (Dali::Vector3 *)jarg1;
6833   {
6834     try {
6835       result = (Dali::Vector2 *) &((Dali::Vector3 const *)arg1)->GetVectorYZ();
6836     } catch (std::out_of_range& e) {
6837       {
6838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
6839       };
6840     } catch (std::exception& e) {
6841       {
6842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
6843       };
6844     } catch (Dali::DaliException e) {
6845       {
6846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
6847       };
6848     } catch (...) {
6849       {
6850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
6851       };
6852     }
6853   }
6854
6855   jresult = (void *)result;
6856   return jresult;
6857 }
6858
6859
6860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_X_set(void * jarg1, float jarg2) {
6861   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6862   float arg2 ;
6863
6864   arg1 = (Dali::Vector3 *)jarg1;
6865   arg2 = (float)jarg2;
6866   if (arg1) (arg1)->x = arg2;
6867 }
6868
6869
6870 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_X_get(void * jarg1) {
6871   float jresult ;
6872   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6873   float result;
6874
6875   arg1 = (Dali::Vector3 *)jarg1;
6876   result = (float) ((arg1)->x);
6877   jresult = result;
6878   return jresult;
6879 }
6880
6881
6882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Width_set(void * jarg1, float jarg2) {
6883   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6884   float arg2 ;
6885
6886   arg1 = (Dali::Vector3 *)jarg1;
6887   arg2 = (float)jarg2;
6888   if (arg1) (arg1)->width = arg2;
6889 }
6890
6891
6892 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Width_get(void * jarg1) {
6893   float jresult ;
6894   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6895   float result;
6896
6897   arg1 = (Dali::Vector3 *)jarg1;
6898   result = (float) ((arg1)->width);
6899   jresult = result;
6900   return jresult;
6901 }
6902
6903
6904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_r_set(void * jarg1, float jarg2) {
6905   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6906   float arg2 ;
6907
6908   arg1 = (Dali::Vector3 *)jarg1;
6909   arg2 = (float)jarg2;
6910   if (arg1) (arg1)->r = arg2;
6911 }
6912
6913
6914 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_r_get(void * jarg1) {
6915   float jresult ;
6916   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6917   float result;
6918
6919   arg1 = (Dali::Vector3 *)jarg1;
6920   result = (float) ((arg1)->r);
6921   jresult = result;
6922   return jresult;
6923 }
6924
6925
6926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Y_set(void * jarg1, float jarg2) {
6927   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6928   float arg2 ;
6929
6930   arg1 = (Dali::Vector3 *)jarg1;
6931   arg2 = (float)jarg2;
6932   if (arg1) (arg1)->y = arg2;
6933 }
6934
6935
6936 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Y_get(void * jarg1) {
6937   float jresult ;
6938   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6939   float result;
6940
6941   arg1 = (Dali::Vector3 *)jarg1;
6942   result = (float) ((arg1)->y);
6943   jresult = result;
6944   return jresult;
6945 }
6946
6947
6948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Height_set(void * jarg1, float jarg2) {
6949   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6950   float arg2 ;
6951
6952   arg1 = (Dali::Vector3 *)jarg1;
6953   arg2 = (float)jarg2;
6954   if (arg1) (arg1)->height = arg2;
6955 }
6956
6957
6958 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Height_get(void * jarg1) {
6959   float jresult ;
6960   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6961   float result;
6962
6963   arg1 = (Dali::Vector3 *)jarg1;
6964   result = (float) ((arg1)->height);
6965   jresult = result;
6966   return jresult;
6967 }
6968
6969
6970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_g_set(void * jarg1, float jarg2) {
6971   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6972   float arg2 ;
6973
6974   arg1 = (Dali::Vector3 *)jarg1;
6975   arg2 = (float)jarg2;
6976   if (arg1) (arg1)->g = arg2;
6977 }
6978
6979
6980 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_g_get(void * jarg1) {
6981   float jresult ;
6982   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6983   float result;
6984
6985   arg1 = (Dali::Vector3 *)jarg1;
6986   result = (float) ((arg1)->g);
6987   jresult = result;
6988   return jresult;
6989 }
6990
6991
6992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Z_set(void * jarg1, float jarg2) {
6993   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
6994   float arg2 ;
6995
6996   arg1 = (Dali::Vector3 *)jarg1;
6997   arg2 = (float)jarg2;
6998   if (arg1) (arg1)->z = arg2;
6999 }
7000
7001
7002 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Z_get(void * jarg1) {
7003   float jresult ;
7004   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7005   float result;
7006
7007   arg1 = (Dali::Vector3 *)jarg1;
7008   result = (float) ((arg1)->z);
7009   jresult = result;
7010   return jresult;
7011 }
7012
7013
7014 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_Depth_set(void * jarg1, float jarg2) {
7015   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7016   float arg2 ;
7017
7018   arg1 = (Dali::Vector3 *)jarg1;
7019   arg2 = (float)jarg2;
7020   if (arg1) (arg1)->depth = arg2;
7021 }
7022
7023
7024 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_Depth_get(void * jarg1) {
7025   float jresult ;
7026   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7027   float result;
7028
7029   arg1 = (Dali::Vector3 *)jarg1;
7030   result = (float) ((arg1)->depth);
7031   jresult = result;
7032   return jresult;
7033 }
7034
7035
7036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector3_b_set(void * jarg1, float jarg2) {
7037   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7038   float arg2 ;
7039
7040   arg1 = (Dali::Vector3 *)jarg1;
7041   arg2 = (float)jarg2;
7042   if (arg1) (arg1)->b = arg2;
7043 }
7044
7045
7046 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector3_b_get(void * jarg1) {
7047   float jresult ;
7048   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7049   float result;
7050
7051   arg1 = (Dali::Vector3 *)jarg1;
7052   result = (float) ((arg1)->b);
7053   jresult = result;
7054   return jresult;
7055 }
7056
7057
7058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector3(void * jarg1) {
7059   Dali::Vector3 *arg1 = (Dali::Vector3 *) 0 ;
7060
7061   arg1 = (Dali::Vector3 *)jarg1;
7062   {
7063     try {
7064       delete arg1;
7065     } catch (std::out_of_range& e) {
7066       {
7067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
7068       };
7069     } catch (std::exception& e) {
7070       {
7071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
7072       };
7073     } catch (Dali::DaliException e) {
7074       {
7075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
7076       };
7077     } catch (...) {
7078       {
7079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
7080       };
7081     }
7082   }
7083
7084 }
7085
7086
7087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_1(void * jarg1, void * jarg2) {
7088   void * jresult ;
7089   Dali::Vector3 *arg1 = 0 ;
7090   Dali::Vector3 *arg2 = 0 ;
7091   Dali::Vector3 result;
7092
7093   arg1 = (Dali::Vector3 *)jarg1;
7094   if (!arg1) {
7095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7096     return 0;
7097   }
7098   arg2 = (Dali::Vector3 *)jarg2;
7099   if (!arg2) {
7100     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7101     return 0;
7102   }
7103   {
7104     try {
7105       result = Dali::Min((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7106     } catch (std::out_of_range& e) {
7107       {
7108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7109       };
7110     } catch (std::exception& e) {
7111       {
7112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7113       };
7114     } catch (Dali::DaliException e) {
7115       {
7116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7117       };
7118     } catch (...) {
7119       {
7120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7121       };
7122     }
7123   }
7124
7125   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7126   return jresult;
7127 }
7128
7129
7130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_1(void * jarg1, void * jarg2) {
7131   void * jresult ;
7132   Dali::Vector3 *arg1 = 0 ;
7133   Dali::Vector3 *arg2 = 0 ;
7134   Dali::Vector3 result;
7135
7136   arg1 = (Dali::Vector3 *)jarg1;
7137   if (!arg1) {
7138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7139     return 0;
7140   }
7141   arg2 = (Dali::Vector3 *)jarg2;
7142   if (!arg2) {
7143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7144     return 0;
7145   }
7146   {
7147     try {
7148       result = Dali::Max((Dali::Vector3 const &)*arg1,(Dali::Vector3 const &)*arg2);
7149     } catch (std::out_of_range& e) {
7150       {
7151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7152       };
7153     } catch (std::exception& e) {
7154       {
7155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7156       };
7157     } catch (Dali::DaliException e) {
7158       {
7159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7160       };
7161     } catch (...) {
7162       {
7163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7164       };
7165     }
7166   }
7167
7168   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7169   return jresult;
7170 }
7171
7172
7173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
7174   void * jresult ;
7175   Dali::Vector3 *arg1 = 0 ;
7176   float *arg2 = 0 ;
7177   float *arg3 = 0 ;
7178   float temp2 ;
7179   float temp3 ;
7180   Dali::Vector3 result;
7181
7182   arg1 = (Dali::Vector3 *)jarg1;
7183   if (!arg1) {
7184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7185     return 0;
7186   }
7187   temp2 = (float)jarg2;
7188   arg2 = &temp2;
7189   temp3 = (float)jarg3;
7190   arg3 = &temp3;
7191   {
7192     try {
7193       result = Dali::Clamp((Dali::Vector3 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
7194     } catch (std::out_of_range& e) {
7195       {
7196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7197       };
7198     } catch (std::exception& e) {
7199       {
7200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7201       };
7202     } catch (Dali::DaliException e) {
7203       {
7204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7205       };
7206     } catch (...) {
7207       {
7208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7209       };
7210     }
7211   }
7212
7213   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
7214   return jresult;
7215 }
7216
7217
7218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_0() {
7219   void * jresult ;
7220   Dali::Vector4 *result = 0 ;
7221
7222   {
7223     try {
7224       result = (Dali::Vector4 *)new Dali::Vector4();
7225     } catch (std::out_of_range& e) {
7226       {
7227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7228       };
7229     } catch (std::exception& e) {
7230       {
7231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7232       };
7233     } catch (Dali::DaliException e) {
7234       {
7235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7236       };
7237     } catch (...) {
7238       {
7239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7240       };
7241     }
7242   }
7243
7244   jresult = (void *)result;
7245   return jresult;
7246 }
7247
7248
7249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
7250   void * jresult ;
7251   float arg1 ;
7252   float arg2 ;
7253   float arg3 ;
7254   float arg4 ;
7255   Dali::Vector4 *result = 0 ;
7256
7257   arg1 = (float)jarg1;
7258   arg2 = (float)jarg2;
7259   arg3 = (float)jarg3;
7260   arg4 = (float)jarg4;
7261   {
7262     try {
7263       result = (Dali::Vector4 *)new Dali::Vector4(arg1,arg2,arg3,arg4);
7264     } catch (std::out_of_range& e) {
7265       {
7266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7267       };
7268     } catch (std::exception& e) {
7269       {
7270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7271       };
7272     } catch (Dali::DaliException e) {
7273       {
7274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7275       };
7276     } catch (...) {
7277       {
7278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7279       };
7280     }
7281   }
7282
7283   jresult = (void *)result;
7284   return jresult;
7285 }
7286
7287
7288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_2(float* jarg1) {
7289   void * jresult ;
7290   float *arg1 = (float *) 0 ;
7291   Dali::Vector4 *result = 0 ;
7292
7293   arg1 = jarg1;
7294   {
7295     try {
7296       result = (Dali::Vector4 *)new Dali::Vector4((float const *)arg1);
7297     } catch (std::out_of_range& e) {
7298       {
7299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7300       };
7301     } catch (std::exception& e) {
7302       {
7303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7304       };
7305     } catch (Dali::DaliException e) {
7306       {
7307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7308       };
7309     } catch (...) {
7310       {
7311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7312       };
7313     }
7314   }
7315
7316   jresult = (void *)result;
7317
7318
7319   return jresult;
7320 }
7321
7322
7323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_3(void * jarg1) {
7324   void * jresult ;
7325   Dali::Vector2 *arg1 = 0 ;
7326   Dali::Vector4 *result = 0 ;
7327
7328   arg1 = (Dali::Vector2 *)jarg1;
7329   if (!arg1) {
7330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7331     return 0;
7332   }
7333   {
7334     try {
7335       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector2 const &)*arg1);
7336     } catch (std::out_of_range& e) {
7337       {
7338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7339       };
7340     } catch (std::exception& e) {
7341       {
7342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7343       };
7344     } catch (Dali::DaliException e) {
7345       {
7346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7347       };
7348     } catch (...) {
7349       {
7350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7351       };
7352     }
7353   }
7354
7355   jresult = (void *)result;
7356   return jresult;
7357 }
7358
7359
7360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Vector4__SWIG_4(void * jarg1) {
7361   void * jresult ;
7362   Dali::Vector3 *arg1 = 0 ;
7363   Dali::Vector4 *result = 0 ;
7364
7365   arg1 = (Dali::Vector3 *)jarg1;
7366   if (!arg1) {
7367     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7368     return 0;
7369   }
7370   {
7371     try {
7372       result = (Dali::Vector4 *)new Dali::Vector4((Dali::Vector3 const &)*arg1);
7373     } catch (std::out_of_range& e) {
7374       {
7375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7376       };
7377     } catch (std::exception& e) {
7378       {
7379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7380       };
7381     } catch (Dali::DaliException e) {
7382       {
7383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7384       };
7385     } catch (...) {
7386       {
7387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7388       };
7389     }
7390   }
7391
7392   jresult = (void *)result;
7393   return jresult;
7394 }
7395
7396
7397 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ONE_get() {
7398   void * jresult ;
7399   Dali::Vector4 *result = 0 ;
7400
7401   result = (Dali::Vector4 *)&Dali::Vector4::ONE;
7402   jresult = (void *)result;
7403   return jresult;
7404 }
7405
7406
7407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_XAXIS_get() {
7408   void * jresult ;
7409   Dali::Vector4 *result = 0 ;
7410
7411   result = (Dali::Vector4 *)&Dali::Vector4::XAXIS;
7412   jresult = (void *)result;
7413   return jresult;
7414 }
7415
7416
7417 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_YAXIS_get() {
7418   void * jresult ;
7419   Dali::Vector4 *result = 0 ;
7420
7421   result = (Dali::Vector4 *)&Dali::Vector4::YAXIS;
7422   jresult = (void *)result;
7423   return jresult;
7424 }
7425
7426
7427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZAXIS_get() {
7428   void * jresult ;
7429   Dali::Vector4 *result = 0 ;
7430
7431   result = (Dali::Vector4 *)&Dali::Vector4::ZAXIS;
7432   jresult = (void *)result;
7433   return jresult;
7434 }
7435
7436
7437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_ZERO_get() {
7438   void * jresult ;
7439   Dali::Vector4 *result = 0 ;
7440
7441   result = (Dali::Vector4 *)&Dali::Vector4::ZERO;
7442   jresult = (void *)result;
7443   return jresult;
7444 }
7445
7446
7447 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_0(void * jarg1, float* jarg2) {
7448   void * jresult ;
7449   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7450   float *arg2 = (float *) 0 ;
7451   Dali::Vector4 *result = 0 ;
7452
7453   arg1 = (Dali::Vector4 *)jarg1;
7454   arg2 = jarg2;
7455   {
7456     try {
7457       result = (Dali::Vector4 *) &(arg1)->operator =((float const *)arg2);
7458     } catch (std::out_of_range& e) {
7459       {
7460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7461       };
7462     } catch (std::exception& e) {
7463       {
7464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7465       };
7466     } catch (Dali::DaliException e) {
7467       {
7468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7469       };
7470     } catch (...) {
7471       {
7472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7473       };
7474     }
7475   }
7476
7477   jresult = (void *)result;
7478
7479
7480   return jresult;
7481 }
7482
7483
7484 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_1(void * jarg1, void * jarg2) {
7485   void * jresult ;
7486   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7487   Dali::Vector2 *arg2 = 0 ;
7488   Dali::Vector4 *result = 0 ;
7489
7490   arg1 = (Dali::Vector4 *)jarg1;
7491   arg2 = (Dali::Vector2 *)jarg2;
7492   if (!arg2) {
7493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
7494     return 0;
7495   }
7496   {
7497     try {
7498       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector2 const &)*arg2);
7499     } catch (std::out_of_range& e) {
7500       {
7501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7502       };
7503     } catch (std::exception& e) {
7504       {
7505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7506       };
7507     } catch (Dali::DaliException e) {
7508       {
7509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7510       };
7511     } catch (...) {
7512       {
7513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7514       };
7515     }
7516   }
7517
7518   jresult = (void *)result;
7519   return jresult;
7520 }
7521
7522
7523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Assign__SWIG_2(void * jarg1, void * jarg2) {
7524   void * jresult ;
7525   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7526   Dali::Vector3 *arg2 = 0 ;
7527   Dali::Vector4 *result = 0 ;
7528
7529   arg1 = (Dali::Vector4 *)jarg1;
7530   arg2 = (Dali::Vector3 *)jarg2;
7531   if (!arg2) {
7532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
7533     return 0;
7534   }
7535   {
7536     try {
7537       result = (Dali::Vector4 *) &(arg1)->operator =((Dali::Vector3 const &)*arg2);
7538     } catch (std::out_of_range& e) {
7539       {
7540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7541       };
7542     } catch (std::exception& e) {
7543       {
7544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7545       };
7546     } catch (Dali::DaliException e) {
7547       {
7548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7549       };
7550     } catch (...) {
7551       {
7552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7553       };
7554     }
7555   }
7556
7557   jresult = (void *)result;
7558   return jresult;
7559 }
7560
7561
7562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Add(void * jarg1, void * jarg2) {
7563   void * jresult ;
7564   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7565   Dali::Vector4 *arg2 = 0 ;
7566   Dali::Vector4 result;
7567
7568   arg1 = (Dali::Vector4 *)jarg1;
7569   arg2 = (Dali::Vector4 *)jarg2;
7570   if (!arg2) {
7571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7572     return 0;
7573   }
7574   {
7575     try {
7576       result = ((Dali::Vector4 const *)arg1)->operator +((Dali::Vector4 const &)*arg2);
7577     } catch (std::out_of_range& e) {
7578       {
7579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7580       };
7581     } catch (std::exception& e) {
7582       {
7583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7584       };
7585     } catch (Dali::DaliException e) {
7586       {
7587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7588       };
7589     } catch (...) {
7590       {
7591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7592       };
7593     }
7594   }
7595
7596   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7597   return jresult;
7598 }
7599
7600
7601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AddAssign(void * jarg1, void * jarg2) {
7602   void * jresult ;
7603   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7604   Dali::Vector4 *arg2 = 0 ;
7605   Dali::Vector4 *result = 0 ;
7606
7607   arg1 = (Dali::Vector4 *)jarg1;
7608   arg2 = (Dali::Vector4 *)jarg2;
7609   if (!arg2) {
7610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7611     return 0;
7612   }
7613   {
7614     try {
7615       result = (Dali::Vector4 *) &(arg1)->operator +=((Dali::Vector4 const &)*arg2);
7616     } catch (std::out_of_range& e) {
7617       {
7618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7619       };
7620     } catch (std::exception& e) {
7621       {
7622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7623       };
7624     } catch (Dali::DaliException e) {
7625       {
7626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7627       };
7628     } catch (...) {
7629       {
7630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7631       };
7632     }
7633   }
7634
7635   jresult = (void *)result;
7636   return jresult;
7637 }
7638
7639
7640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_0(void * jarg1, void * jarg2) {
7641   void * jresult ;
7642   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7643   Dali::Vector4 *arg2 = 0 ;
7644   Dali::Vector4 result;
7645
7646   arg1 = (Dali::Vector4 *)jarg1;
7647   arg2 = (Dali::Vector4 *)jarg2;
7648   if (!arg2) {
7649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7650     return 0;
7651   }
7652   {
7653     try {
7654       result = ((Dali::Vector4 const *)arg1)->operator -((Dali::Vector4 const &)*arg2);
7655     } catch (std::out_of_range& e) {
7656       {
7657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7658       };
7659     } catch (std::exception& e) {
7660       {
7661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7662       };
7663     } catch (Dali::DaliException e) {
7664       {
7665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7666       };
7667     } catch (...) {
7668       {
7669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7670       };
7671     }
7672   }
7673
7674   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7675   return jresult;
7676 }
7677
7678
7679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_SubtractAssign(void * jarg1, void * jarg2) {
7680   void * jresult ;
7681   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7682   Dali::Vector4 *arg2 = 0 ;
7683   Dali::Vector4 *result = 0 ;
7684
7685   arg1 = (Dali::Vector4 *)jarg1;
7686   arg2 = (Dali::Vector4 *)jarg2;
7687   if (!arg2) {
7688     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7689     return 0;
7690   }
7691   {
7692     try {
7693       result = (Dali::Vector4 *) &(arg1)->operator -=((Dali::Vector4 const &)*arg2);
7694     } catch (std::out_of_range& e) {
7695       {
7696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7697       };
7698     } catch (std::exception& e) {
7699       {
7700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7701       };
7702     } catch (Dali::DaliException e) {
7703       {
7704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7705       };
7706     } catch (...) {
7707       {
7708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7709       };
7710     }
7711   }
7712
7713   jresult = (void *)result;
7714   return jresult;
7715 }
7716
7717
7718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_0(void * jarg1, void * jarg2) {
7719   void * jresult ;
7720   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7721   Dali::Vector4 *arg2 = 0 ;
7722   Dali::Vector4 result;
7723
7724   arg1 = (Dali::Vector4 *)jarg1;
7725   arg2 = (Dali::Vector4 *)jarg2;
7726   if (!arg2) {
7727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7728     return 0;
7729   }
7730   {
7731     try {
7732       result = ((Dali::Vector4 const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
7733     } catch (std::out_of_range& e) {
7734       {
7735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7736       };
7737     } catch (std::exception& e) {
7738       {
7739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7740       };
7741     } catch (Dali::DaliException e) {
7742       {
7743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7744       };
7745     } catch (...) {
7746       {
7747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7748       };
7749     }
7750   }
7751
7752   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7753   return jresult;
7754 }
7755
7756
7757 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Multiply__SWIG_1(void * jarg1, float jarg2) {
7758   void * jresult ;
7759   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7760   float arg2 ;
7761   Dali::Vector4 result;
7762
7763   arg1 = (Dali::Vector4 *)jarg1;
7764   arg2 = (float)jarg2;
7765   {
7766     try {
7767       result = ((Dali::Vector4 const *)arg1)->operator *(arg2);
7768     } catch (std::out_of_range& e) {
7769       {
7770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7771       };
7772     } catch (std::exception& e) {
7773       {
7774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7775       };
7776     } catch (Dali::DaliException e) {
7777       {
7778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7779       };
7780     } catch (...) {
7781       {
7782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7783       };
7784     }
7785   }
7786
7787   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7788   return jresult;
7789 }
7790
7791
7792 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
7793   void * jresult ;
7794   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7795   Dali::Vector4 *arg2 = 0 ;
7796   Dali::Vector4 *result = 0 ;
7797
7798   arg1 = (Dali::Vector4 *)jarg1;
7799   arg2 = (Dali::Vector4 *)jarg2;
7800   if (!arg2) {
7801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7802     return 0;
7803   }
7804   {
7805     try {
7806       result = (Dali::Vector4 *) &(arg1)->operator *=((Dali::Vector4 const &)*arg2);
7807     } catch (std::out_of_range& e) {
7808       {
7809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7810       };
7811     } catch (std::exception& e) {
7812       {
7813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7814       };
7815     } catch (Dali::DaliException e) {
7816       {
7817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7818       };
7819     } catch (...) {
7820       {
7821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7822       };
7823     }
7824   }
7825
7826   jresult = (void *)result;
7827   return jresult;
7828 }
7829
7830
7831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
7832   void * jresult ;
7833   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7834   float arg2 ;
7835   Dali::Vector4 *result = 0 ;
7836
7837   arg1 = (Dali::Vector4 *)jarg1;
7838   arg2 = (float)jarg2;
7839   {
7840     try {
7841       result = (Dali::Vector4 *) &(arg1)->operator *=(arg2);
7842     } catch (std::out_of_range& e) {
7843       {
7844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7845       };
7846     } catch (std::exception& e) {
7847       {
7848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7849       };
7850     } catch (Dali::DaliException e) {
7851       {
7852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7853       };
7854     } catch (...) {
7855       {
7856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7857       };
7858     }
7859   }
7860
7861   jresult = (void *)result;
7862   return jresult;
7863 }
7864
7865
7866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_0(void * jarg1, void * jarg2) {
7867   void * jresult ;
7868   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7869   Dali::Vector4 *arg2 = 0 ;
7870   Dali::Vector4 result;
7871
7872   arg1 = (Dali::Vector4 *)jarg1;
7873   arg2 = (Dali::Vector4 *)jarg2;
7874   if (!arg2) {
7875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7876     return 0;
7877   }
7878   {
7879     try {
7880       result = ((Dali::Vector4 const *)arg1)->operator /((Dali::Vector4 const &)*arg2);
7881     } catch (std::out_of_range& e) {
7882       {
7883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7884       };
7885     } catch (std::exception& e) {
7886       {
7887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7888       };
7889     } catch (Dali::DaliException e) {
7890       {
7891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7892       };
7893     } catch (...) {
7894       {
7895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7896       };
7897     }
7898   }
7899
7900   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7901   return jresult;
7902 }
7903
7904
7905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Divide__SWIG_1(void * jarg1, float jarg2) {
7906   void * jresult ;
7907   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7908   float arg2 ;
7909   Dali::Vector4 result;
7910
7911   arg1 = (Dali::Vector4 *)jarg1;
7912   arg2 = (float)jarg2;
7913   {
7914     try {
7915       result = ((Dali::Vector4 const *)arg1)->operator /(arg2);
7916     } catch (std::out_of_range& e) {
7917       {
7918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7919       };
7920     } catch (std::exception& e) {
7921       {
7922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7923       };
7924     } catch (Dali::DaliException e) {
7925       {
7926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7927       };
7928     } catch (...) {
7929       {
7930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7931       };
7932     }
7933   }
7934
7935   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
7936   return jresult;
7937 }
7938
7939
7940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_0(void * jarg1, void * jarg2) {
7941   void * jresult ;
7942   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7943   Dali::Vector4 *arg2 = 0 ;
7944   Dali::Vector4 *result = 0 ;
7945
7946   arg1 = (Dali::Vector4 *)jarg1;
7947   arg2 = (Dali::Vector4 *)jarg2;
7948   if (!arg2) {
7949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
7950     return 0;
7951   }
7952   {
7953     try {
7954       result = (Dali::Vector4 *) &(arg1)->operator /=((Dali::Vector4 const &)*arg2);
7955     } catch (std::out_of_range& e) {
7956       {
7957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7958       };
7959     } catch (std::exception& e) {
7960       {
7961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7962       };
7963     } catch (Dali::DaliException e) {
7964       {
7965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
7966       };
7967     } catch (...) {
7968       {
7969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
7970       };
7971     }
7972   }
7973
7974   jresult = (void *)result;
7975   return jresult;
7976 }
7977
7978
7979 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_DivideAssign__SWIG_1(void * jarg1, float jarg2) {
7980   void * jresult ;
7981   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
7982   float arg2 ;
7983   Dali::Vector4 *result = 0 ;
7984
7985   arg1 = (Dali::Vector4 *)jarg1;
7986   arg2 = (float)jarg2;
7987   {
7988     try {
7989       result = (Dali::Vector4 *) &(arg1)->operator /=(arg2);
7990     } catch (std::out_of_range& e) {
7991       {
7992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
7993       };
7994     } catch (std::exception& e) {
7995       {
7996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
7997       };
7998     } catch (Dali::DaliException e) {
7999       {
8000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8001       };
8002     } catch (...) {
8003       {
8004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8005       };
8006     }
8007   }
8008
8009   jresult = (void *)result;
8010   return jresult;
8011 }
8012
8013
8014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Subtract__SWIG_1(void * jarg1) {
8015   void * jresult ;
8016   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8017   Dali::Vector4 result;
8018
8019   arg1 = (Dali::Vector4 *)jarg1;
8020   {
8021     try {
8022       result = ((Dali::Vector4 const *)arg1)->operator -();
8023     } catch (std::out_of_range& e) {
8024       {
8025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8026       };
8027     } catch (std::exception& e) {
8028       {
8029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8030       };
8031     } catch (Dali::DaliException e) {
8032       {
8033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8034       };
8035     } catch (...) {
8036       {
8037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8038       };
8039     }
8040   }
8041
8042   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8043   return jresult;
8044 }
8045
8046
8047 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_EqualTo(void * jarg1, void * jarg2) {
8048   unsigned int jresult ;
8049   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8050   Dali::Vector4 *arg2 = 0 ;
8051   bool result;
8052
8053   arg1 = (Dali::Vector4 *)jarg1;
8054   arg2 = (Dali::Vector4 *)jarg2;
8055   if (!arg2) {
8056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8057     return 0;
8058   }
8059   {
8060     try {
8061       result = (bool)((Dali::Vector4 const *)arg1)->operator ==((Dali::Vector4 const &)*arg2);
8062     } catch (std::out_of_range& e) {
8063       {
8064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8065       };
8066     } catch (std::exception& e) {
8067       {
8068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8069       };
8070     } catch (Dali::DaliException e) {
8071       {
8072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8073       };
8074     } catch (...) {
8075       {
8076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8077       };
8078     }
8079   }
8080
8081   jresult = result;
8082   return jresult;
8083 }
8084
8085
8086 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Vector4_NotEqualTo(void * jarg1, void * jarg2) {
8087   unsigned int jresult ;
8088   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8089   Dali::Vector4 *arg2 = 0 ;
8090   bool result;
8091
8092   arg1 = (Dali::Vector4 *)jarg1;
8093   arg2 = (Dali::Vector4 *)jarg2;
8094   if (!arg2) {
8095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8096     return 0;
8097   }
8098   {
8099     try {
8100       result = (bool)((Dali::Vector4 const *)arg1)->operator !=((Dali::Vector4 const &)*arg2);
8101     } catch (std::out_of_range& e) {
8102       {
8103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8104       };
8105     } catch (std::exception& e) {
8106       {
8107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8108       };
8109     } catch (Dali::DaliException e) {
8110       {
8111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8112       };
8113     } catch (...) {
8114       {
8115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8116       };
8117     }
8118   }
8119
8120   jresult = result;
8121   return jresult;
8122 }
8123
8124
8125 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_ValueOfIndex__SWIG_0(void * jarg1, unsigned int jarg2) {
8126   float jresult ;
8127   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8128   unsigned int arg2 ;
8129   float *result = 0 ;
8130
8131   arg1 = (Dali::Vector4 *)jarg1;
8132   arg2 = (unsigned int)jarg2;
8133   {
8134     try {
8135       result = (float *) &((Dali::Vector4 const *)arg1)->operator [](arg2);
8136     } catch (std::out_of_range& e) {
8137       {
8138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8139       };
8140     } catch (std::exception& e) {
8141       {
8142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8143       };
8144     } catch (Dali::DaliException e) {
8145       {
8146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8147       };
8148     } catch (...) {
8149       {
8150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8151       };
8152     }
8153   }
8154
8155   jresult = *result;
8156   return jresult;
8157 }
8158
8159
8160 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_0(void * jarg1, void * jarg2) {
8161   float jresult ;
8162   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8163   Dali::Vector3 *arg2 = 0 ;
8164   float result;
8165
8166   arg1 = (Dali::Vector4 *)jarg1;
8167   arg2 = (Dali::Vector3 *)jarg2;
8168   if (!arg2) {
8169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
8170     return 0;
8171   }
8172   {
8173     try {
8174       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector3 const &)*arg2);
8175     } catch (std::out_of_range& e) {
8176       {
8177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8178       };
8179     } catch (std::exception& e) {
8180       {
8181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8182       };
8183     } catch (Dali::DaliException e) {
8184       {
8185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8186       };
8187     } catch (...) {
8188       {
8189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8190       };
8191     }
8192   }
8193
8194   jresult = result;
8195   return jresult;
8196 }
8197
8198
8199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot__SWIG_1(void * jarg1, void * jarg2) {
8200   float jresult ;
8201   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8202   Dali::Vector4 *arg2 = 0 ;
8203   float result;
8204
8205   arg1 = (Dali::Vector4 *)jarg1;
8206   arg2 = (Dali::Vector4 *)jarg2;
8207   if (!arg2) {
8208     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8209     return 0;
8210   }
8211   {
8212     try {
8213       result = (float)((Dali::Vector4 const *)arg1)->Dot((Dali::Vector4 const &)*arg2);
8214     } catch (std::out_of_range& e) {
8215       {
8216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8217       };
8218     } catch (std::exception& e) {
8219       {
8220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8221       };
8222     } catch (Dali::DaliException e) {
8223       {
8224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8225       };
8226     } catch (...) {
8227       {
8228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8229       };
8230     }
8231   }
8232
8233   jresult = result;
8234   return jresult;
8235 }
8236
8237
8238 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Dot4(void * jarg1, void * jarg2) {
8239   float jresult ;
8240   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8241   Dali::Vector4 *arg2 = 0 ;
8242   float result;
8243
8244   arg1 = (Dali::Vector4 *)jarg1;
8245   arg2 = (Dali::Vector4 *)jarg2;
8246   if (!arg2) {
8247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8248     return 0;
8249   }
8250   {
8251     try {
8252       result = (float)((Dali::Vector4 const *)arg1)->Dot4((Dali::Vector4 const &)*arg2);
8253     } catch (std::out_of_range& e) {
8254       {
8255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8256       };
8257     } catch (std::exception& e) {
8258       {
8259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8260       };
8261     } catch (Dali::DaliException e) {
8262       {
8263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8264       };
8265     } catch (...) {
8266       {
8267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8268       };
8269     }
8270   }
8271
8272   jresult = result;
8273   return jresult;
8274 }
8275
8276
8277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_Cross(void * jarg1, void * jarg2) {
8278   void * jresult ;
8279   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8280   Dali::Vector4 *arg2 = 0 ;
8281   Dali::Vector4 result;
8282
8283   arg1 = (Dali::Vector4 *)jarg1;
8284   arg2 = (Dali::Vector4 *)jarg2;
8285   if (!arg2) {
8286     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8287     return 0;
8288   }
8289   {
8290     try {
8291       result = ((Dali::Vector4 const *)arg1)->Cross((Dali::Vector4 const &)*arg2);
8292     } catch (std::out_of_range& e) {
8293       {
8294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8295       };
8296     } catch (std::exception& e) {
8297       {
8298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8299       };
8300     } catch (Dali::DaliException e) {
8301       {
8302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8303       };
8304     } catch (...) {
8305       {
8306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8307       };
8308     }
8309   }
8310
8311   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8312   return jresult;
8313 }
8314
8315
8316 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Length(void * jarg1) {
8317   float jresult ;
8318   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8319   float result;
8320
8321   arg1 = (Dali::Vector4 *)jarg1;
8322   {
8323     try {
8324       result = (float)((Dali::Vector4 const *)arg1)->Length();
8325     } catch (std::out_of_range& e) {
8326       {
8327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8328       };
8329     } catch (std::exception& e) {
8330       {
8331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8332       };
8333     } catch (Dali::DaliException e) {
8334       {
8335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8336       };
8337     } catch (...) {
8338       {
8339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8340       };
8341     }
8342   }
8343
8344   jresult = result;
8345   return jresult;
8346 }
8347
8348
8349 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_LengthSquared(void * jarg1) {
8350   float jresult ;
8351   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8352   float result;
8353
8354   arg1 = (Dali::Vector4 *)jarg1;
8355   {
8356     try {
8357       result = (float)((Dali::Vector4 const *)arg1)->LengthSquared();
8358     } catch (std::out_of_range& e) {
8359       {
8360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8361       };
8362     } catch (std::exception& e) {
8363       {
8364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8365       };
8366     } catch (Dali::DaliException e) {
8367       {
8368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8369       };
8370     } catch (...) {
8371       {
8372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8373       };
8374     }
8375   }
8376
8377   jresult = result;
8378   return jresult;
8379 }
8380
8381
8382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Normalize(void * jarg1) {
8383   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8384
8385   arg1 = (Dali::Vector4 *)jarg1;
8386   {
8387     try {
8388       (arg1)->Normalize();
8389     } catch (std::out_of_range& e) {
8390       {
8391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8392       };
8393     } catch (std::exception& e) {
8394       {
8395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8396       };
8397     } catch (Dali::DaliException e) {
8398       {
8399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8400       };
8401     } catch (...) {
8402       {
8403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8404       };
8405     }
8406   }
8407
8408 }
8409
8410
8411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Clamp(void * jarg1, void * jarg2, void * jarg3) {
8412   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8413   Dali::Vector4 *arg2 = 0 ;
8414   Dali::Vector4 *arg3 = 0 ;
8415
8416   arg1 = (Dali::Vector4 *)jarg1;
8417   arg2 = (Dali::Vector4 *)jarg2;
8418   if (!arg2) {
8419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8420     return ;
8421   }
8422   arg3 = (Dali::Vector4 *)jarg3;
8423   if (!arg3) {
8424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8425     return ;
8426   }
8427   {
8428     try {
8429       (arg1)->Clamp((Dali::Vector4 const &)*arg2,(Dali::Vector4 const &)*arg3);
8430     } catch (std::out_of_range& e) {
8431       {
8432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8433       };
8434     } catch (std::exception& e) {
8435       {
8436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8437       };
8438     } catch (Dali::DaliException e) {
8439       {
8440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8441       };
8442     } catch (...) {
8443       {
8444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8445       };
8446     }
8447   }
8448
8449 }
8450
8451
8452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Vector4_AsFloat__SWIG_0(void * jarg1) {
8453   void * jresult ;
8454   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8455   float *result = 0 ;
8456
8457   arg1 = (Dali::Vector4 *)jarg1;
8458   {
8459     try {
8460       result = (float *)((Dali::Vector4 const *)arg1)->AsFloat();
8461     } catch (std::out_of_range& e) {
8462       {
8463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8464       };
8465     } catch (std::exception& e) {
8466       {
8467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8468       };
8469     } catch (Dali::DaliException e) {
8470       {
8471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8472       };
8473     } catch (...) {
8474       {
8475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8476       };
8477     }
8478   }
8479
8480   jresult = (void *)result;
8481   return jresult;
8482 }
8483
8484
8485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_X_set(void * jarg1, float jarg2) {
8486   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8487   float arg2 ;
8488
8489   arg1 = (Dali::Vector4 *)jarg1;
8490   arg2 = (float)jarg2;
8491   if (arg1) (arg1)->x = arg2;
8492 }
8493
8494
8495 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_X_get(void * jarg1) {
8496   float jresult ;
8497   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8498   float result;
8499
8500   arg1 = (Dali::Vector4 *)jarg1;
8501   result = (float) ((arg1)->x);
8502   jresult = result;
8503   return jresult;
8504 }
8505
8506
8507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_r_set(void * jarg1, float jarg2) {
8508   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8509   float arg2 ;
8510
8511   arg1 = (Dali::Vector4 *)jarg1;
8512   arg2 = (float)jarg2;
8513   if (arg1) (arg1)->r = arg2;
8514 }
8515
8516
8517 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_r_get(void * jarg1) {
8518   float jresult ;
8519   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8520   float result;
8521
8522   arg1 = (Dali::Vector4 *)jarg1;
8523   result = (float) ((arg1)->r);
8524   jresult = result;
8525   return jresult;
8526 }
8527
8528
8529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_s_set(void * jarg1, float jarg2) {
8530   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8531   float arg2 ;
8532
8533   arg1 = (Dali::Vector4 *)jarg1;
8534   arg2 = (float)jarg2;
8535   if (arg1) (arg1)->s = arg2;
8536 }
8537
8538
8539 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_s_get(void * jarg1) {
8540   float jresult ;
8541   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8542   float result;
8543
8544   arg1 = (Dali::Vector4 *)jarg1;
8545   result = (float) ((arg1)->s);
8546   jresult = result;
8547   return jresult;
8548 }
8549
8550
8551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Y_set(void * jarg1, float jarg2) {
8552   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8553   float arg2 ;
8554
8555   arg1 = (Dali::Vector4 *)jarg1;
8556   arg2 = (float)jarg2;
8557   if (arg1) (arg1)->y = arg2;
8558 }
8559
8560
8561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Y_get(void * jarg1) {
8562   float jresult ;
8563   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8564   float result;
8565
8566   arg1 = (Dali::Vector4 *)jarg1;
8567   result = (float) ((arg1)->y);
8568   jresult = result;
8569   return jresult;
8570 }
8571
8572
8573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_g_set(void * jarg1, float jarg2) {
8574   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8575   float arg2 ;
8576
8577   arg1 = (Dali::Vector4 *)jarg1;
8578   arg2 = (float)jarg2;
8579   if (arg1) (arg1)->g = arg2;
8580 }
8581
8582
8583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_g_get(void * jarg1) {
8584   float jresult ;
8585   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8586   float result;
8587
8588   arg1 = (Dali::Vector4 *)jarg1;
8589   result = (float) ((arg1)->g);
8590   jresult = result;
8591   return jresult;
8592 }
8593
8594
8595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_t_set(void * jarg1, float jarg2) {
8596   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8597   float arg2 ;
8598
8599   arg1 = (Dali::Vector4 *)jarg1;
8600   arg2 = (float)jarg2;
8601   if (arg1) (arg1)->t = arg2;
8602 }
8603
8604
8605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_t_get(void * jarg1) {
8606   float jresult ;
8607   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8608   float result;
8609
8610   arg1 = (Dali::Vector4 *)jarg1;
8611   result = (float) ((arg1)->t);
8612   jresult = result;
8613   return jresult;
8614 }
8615
8616
8617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_Z_set(void * jarg1, float jarg2) {
8618   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8619   float arg2 ;
8620
8621   arg1 = (Dali::Vector4 *)jarg1;
8622   arg2 = (float)jarg2;
8623   if (arg1) (arg1)->z = arg2;
8624 }
8625
8626
8627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_Z_get(void * jarg1) {
8628   float jresult ;
8629   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8630   float result;
8631
8632   arg1 = (Dali::Vector4 *)jarg1;
8633   result = (float) ((arg1)->z);
8634   jresult = result;
8635   return jresult;
8636 }
8637
8638
8639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_b_set(void * jarg1, float jarg2) {
8640   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8641   float arg2 ;
8642
8643   arg1 = (Dali::Vector4 *)jarg1;
8644   arg2 = (float)jarg2;
8645   if (arg1) (arg1)->b = arg2;
8646 }
8647
8648
8649 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_b_get(void * jarg1) {
8650   float jresult ;
8651   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8652   float result;
8653
8654   arg1 = (Dali::Vector4 *)jarg1;
8655   result = (float) ((arg1)->b);
8656   jresult = result;
8657   return jresult;
8658 }
8659
8660
8661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_p_set(void * jarg1, float jarg2) {
8662   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8663   float arg2 ;
8664
8665   arg1 = (Dali::Vector4 *)jarg1;
8666   arg2 = (float)jarg2;
8667   if (arg1) (arg1)->p = arg2;
8668 }
8669
8670
8671 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_p_get(void * jarg1) {
8672   float jresult ;
8673   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8674   float result;
8675
8676   arg1 = (Dali::Vector4 *)jarg1;
8677   result = (float) ((arg1)->p);
8678   jresult = result;
8679   return jresult;
8680 }
8681
8682
8683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_W_set(void * jarg1, float jarg2) {
8684   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8685   float arg2 ;
8686
8687   arg1 = (Dali::Vector4 *)jarg1;
8688   arg2 = (float)jarg2;
8689   if (arg1) (arg1)->w = arg2;
8690 }
8691
8692
8693 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_W_get(void * jarg1) {
8694   float jresult ;
8695   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8696   float result;
8697
8698   arg1 = (Dali::Vector4 *)jarg1;
8699   result = (float) ((arg1)->w);
8700   jresult = result;
8701   return jresult;
8702 }
8703
8704
8705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_a_set(void * jarg1, float jarg2) {
8706   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8707   float arg2 ;
8708
8709   arg1 = (Dali::Vector4 *)jarg1;
8710   arg2 = (float)jarg2;
8711   if (arg1) (arg1)->a = arg2;
8712 }
8713
8714
8715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_a_get(void * jarg1) {
8716   float jresult ;
8717   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8718   float result;
8719
8720   arg1 = (Dali::Vector4 *)jarg1;
8721   result = (float) ((arg1)->a);
8722   jresult = result;
8723   return jresult;
8724 }
8725
8726
8727 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Vector4_q_set(void * jarg1, float jarg2) {
8728   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8729   float arg2 ;
8730
8731   arg1 = (Dali::Vector4 *)jarg1;
8732   arg2 = (float)jarg2;
8733   if (arg1) (arg1)->q = arg2;
8734 }
8735
8736
8737 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Vector4_q_get(void * jarg1) {
8738   float jresult ;
8739   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8740   float result;
8741
8742   arg1 = (Dali::Vector4 *)jarg1;
8743   result = (float) ((arg1)->q);
8744   jresult = result;
8745   return jresult;
8746 }
8747
8748
8749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Vector4(void * jarg1) {
8750   Dali::Vector4 *arg1 = (Dali::Vector4 *) 0 ;
8751
8752   arg1 = (Dali::Vector4 *)jarg1;
8753   {
8754     try {
8755       delete arg1;
8756     } catch (std::out_of_range& e) {
8757       {
8758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
8759       };
8760     } catch (std::exception& e) {
8761       {
8762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
8763       };
8764     } catch (Dali::DaliException e) {
8765       {
8766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
8767       };
8768     } catch (...) {
8769       {
8770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
8771       };
8772     }
8773   }
8774
8775 }
8776
8777
8778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Min__SWIG_2(void * jarg1, void * jarg2) {
8779   void * jresult ;
8780   Dali::Vector4 *arg1 = 0 ;
8781   Dali::Vector4 *arg2 = 0 ;
8782   Dali::Vector4 result;
8783
8784   arg1 = (Dali::Vector4 *)jarg1;
8785   if (!arg1) {
8786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8787     return 0;
8788   }
8789   arg2 = (Dali::Vector4 *)jarg2;
8790   if (!arg2) {
8791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8792     return 0;
8793   }
8794   {
8795     try {
8796       result = Dali::Min((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8797     } catch (std::out_of_range& e) {
8798       {
8799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8800       };
8801     } catch (std::exception& e) {
8802       {
8803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8804       };
8805     } catch (Dali::DaliException e) {
8806       {
8807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8808       };
8809     } catch (...) {
8810       {
8811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8812       };
8813     }
8814   }
8815
8816   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8817   return jresult;
8818 }
8819
8820
8821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Max__SWIG_2(void * jarg1, void * jarg2) {
8822   void * jresult ;
8823   Dali::Vector4 *arg1 = 0 ;
8824   Dali::Vector4 *arg2 = 0 ;
8825   Dali::Vector4 result;
8826
8827   arg1 = (Dali::Vector4 *)jarg1;
8828   if (!arg1) {
8829     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8830     return 0;
8831   }
8832   arg2 = (Dali::Vector4 *)jarg2;
8833   if (!arg2) {
8834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8835     return 0;
8836   }
8837   {
8838     try {
8839       result = Dali::Max((Dali::Vector4 const &)*arg1,(Dali::Vector4 const &)*arg2);
8840     } catch (std::out_of_range& e) {
8841       {
8842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8843       };
8844     } catch (std::exception& e) {
8845       {
8846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8847       };
8848     } catch (Dali::DaliException e) {
8849       {
8850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8851       };
8852     } catch (...) {
8853       {
8854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8855       };
8856     }
8857   }
8858
8859   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8860   return jresult;
8861 }
8862
8863
8864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
8865   void * jresult ;
8866   Dali::Vector4 *arg1 = 0 ;
8867   float *arg2 = 0 ;
8868   float *arg3 = 0 ;
8869   float temp2 ;
8870   float temp3 ;
8871   Dali::Vector4 result;
8872
8873   arg1 = (Dali::Vector4 *)jarg1;
8874   if (!arg1) {
8875     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
8876     return 0;
8877   }
8878   temp2 = (float)jarg2;
8879   arg2 = &temp2;
8880   temp3 = (float)jarg3;
8881   arg3 = &temp3;
8882   {
8883     try {
8884       result = Dali::Clamp((Dali::Vector4 const &)*arg1,(float const &)*arg2,(float const &)*arg3);
8885     } catch (std::out_of_range& e) {
8886       {
8887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8888       };
8889     } catch (std::exception& e) {
8890       {
8891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8892       };
8893     } catch (Dali::DaliException e) {
8894       {
8895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8896       };
8897     } catch (...) {
8898       {
8899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8900       };
8901     }
8902   }
8903
8904   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
8905   return jresult;
8906 }
8907
8908
8909 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_0() {
8910   void * jresult ;
8911   Dali::Uint16Pair *result = 0 ;
8912
8913   {
8914     try {
8915       result = (Dali::Uint16Pair *)new Dali::Uint16Pair();
8916     } catch (std::out_of_range& e) {
8917       {
8918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8919       };
8920     } catch (std::exception& e) {
8921       {
8922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8923       };
8924     } catch (Dali::DaliException e) {
8925       {
8926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8927       };
8928     } catch (...) {
8929       {
8930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8931       };
8932     }
8933   }
8934
8935   jresult = (void *)result;
8936   return jresult;
8937 }
8938
8939
8940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_1(unsigned int jarg1, unsigned int jarg2) {
8941   void * jresult ;
8942   uint32_t arg1 ;
8943   uint32_t arg2 ;
8944   Dali::Uint16Pair *result = 0 ;
8945
8946   arg1 = (uint32_t)jarg1;
8947   arg2 = (uint32_t)jarg2;
8948   {
8949     try {
8950       result = (Dali::Uint16Pair *)new Dali::Uint16Pair(arg1,arg2);
8951     } catch (std::out_of_range& e) {
8952       {
8953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8954       };
8955     } catch (std::exception& e) {
8956       {
8957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8958       };
8959     } catch (Dali::DaliException e) {
8960       {
8961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8962       };
8963     } catch (...) {
8964       {
8965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
8966       };
8967     }
8968   }
8969
8970   jresult = (void *)result;
8971   return jresult;
8972 }
8973
8974
8975 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Uint16Pair__SWIG_2(void * jarg1) {
8976   void * jresult ;
8977   Dali::Uint16Pair *arg1 = 0 ;
8978   Dali::Uint16Pair *result = 0 ;
8979
8980   arg1 = (Dali::Uint16Pair *)jarg1;
8981   if (!arg1) {
8982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
8983     return 0;
8984   }
8985   {
8986     try {
8987       result = (Dali::Uint16Pair *)new Dali::Uint16Pair((Dali::Uint16Pair const &)*arg1);
8988     } catch (std::out_of_range& e) {
8989       {
8990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
8991       };
8992     } catch (std::exception& e) {
8993       {
8994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
8995       };
8996     } catch (Dali::DaliException e) {
8997       {
8998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
8999       };
9000     } catch (...) {
9001       {
9002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9003       };
9004     }
9005   }
9006
9007   jresult = (void *)result;
9008   return jresult;
9009 }
9010
9011
9012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetWidth(void * jarg1, unsigned short jarg2) {
9013   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9014   uint16_t arg2 ;
9015
9016   arg1 = (Dali::Uint16Pair *)jarg1;
9017   arg2 = (uint16_t)jarg2;
9018   {
9019     try {
9020       (arg1)->SetWidth(arg2);
9021     } catch (std::out_of_range& e) {
9022       {
9023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9024       };
9025     } catch (std::exception& e) {
9026       {
9027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9028       };
9029     } catch (Dali::DaliException e) {
9030       {
9031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9032       };
9033     } catch (...) {
9034       {
9035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9036       };
9037     }
9038   }
9039
9040 }
9041
9042
9043 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetWidth(void * jarg1) {
9044   unsigned short jresult ;
9045   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9046   uint16_t result;
9047
9048   arg1 = (Dali::Uint16Pair *)jarg1;
9049   {
9050     try {
9051       result = ((Dali::Uint16Pair const *)arg1)->GetWidth();
9052     } catch (std::out_of_range& e) {
9053       {
9054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9055       };
9056     } catch (std::exception& e) {
9057       {
9058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9059       };
9060     } catch (Dali::DaliException e) {
9061       {
9062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9063       };
9064     } catch (...) {
9065       {
9066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9067       };
9068     }
9069   }
9070
9071   jresult = result;
9072   return jresult;
9073 }
9074
9075
9076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetHeight(void * jarg1, unsigned short jarg2) {
9077   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9078   uint16_t arg2 ;
9079
9080   arg1 = (Dali::Uint16Pair *)jarg1;
9081   arg2 = (uint16_t)jarg2;
9082   {
9083     try {
9084       (arg1)->SetHeight(arg2);
9085     } catch (std::out_of_range& e) {
9086       {
9087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9088       };
9089     } catch (std::exception& e) {
9090       {
9091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9092       };
9093     } catch (Dali::DaliException e) {
9094       {
9095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9096       };
9097     } catch (...) {
9098       {
9099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9100       };
9101     }
9102   }
9103
9104 }
9105
9106
9107 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetHeight(void * jarg1) {
9108   unsigned short jresult ;
9109   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9110   uint16_t result;
9111
9112   arg1 = (Dali::Uint16Pair *)jarg1;
9113   {
9114     try {
9115       result = ((Dali::Uint16Pair const *)arg1)->GetHeight();
9116     } catch (std::out_of_range& e) {
9117       {
9118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9119       };
9120     } catch (std::exception& e) {
9121       {
9122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9123       };
9124     } catch (Dali::DaliException e) {
9125       {
9126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9127       };
9128     } catch (...) {
9129       {
9130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9131       };
9132     }
9133   }
9134
9135   jresult = result;
9136   return jresult;
9137 }
9138
9139
9140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetX(void * jarg1, unsigned short jarg2) {
9141   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9142   uint16_t arg2 ;
9143
9144   arg1 = (Dali::Uint16Pair *)jarg1;
9145   arg2 = (uint16_t)jarg2;
9146   {
9147     try {
9148       (arg1)->SetX(arg2);
9149     } catch (std::out_of_range& e) {
9150       {
9151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9152       };
9153     } catch (std::exception& e) {
9154       {
9155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9156       };
9157     } catch (Dali::DaliException e) {
9158       {
9159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9160       };
9161     } catch (...) {
9162       {
9163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9164       };
9165     }
9166   }
9167
9168 }
9169
9170
9171 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetX(void * jarg1) {
9172   unsigned short jresult ;
9173   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9174   uint16_t result;
9175
9176   arg1 = (Dali::Uint16Pair *)jarg1;
9177   {
9178     try {
9179       result = ((Dali::Uint16Pair const *)arg1)->GetX();
9180     } catch (std::out_of_range& e) {
9181       {
9182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9183       };
9184     } catch (std::exception& e) {
9185       {
9186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9187       };
9188     } catch (Dali::DaliException e) {
9189       {
9190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9191       };
9192     } catch (...) {
9193       {
9194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9195       };
9196     }
9197   }
9198
9199   jresult = result;
9200   return jresult;
9201 }
9202
9203
9204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Uint16Pair_SetY(void * jarg1, unsigned short jarg2) {
9205   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9206   uint16_t arg2 ;
9207
9208   arg1 = (Dali::Uint16Pair *)jarg1;
9209   arg2 = (uint16_t)jarg2;
9210   {
9211     try {
9212       (arg1)->SetY(arg2);
9213     } catch (std::out_of_range& e) {
9214       {
9215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9216       };
9217     } catch (std::exception& e) {
9218       {
9219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9220       };
9221     } catch (Dali::DaliException e) {
9222       {
9223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9224       };
9225     } catch (...) {
9226       {
9227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9228       };
9229     }
9230   }
9231
9232 }
9233
9234
9235 SWIGEXPORT unsigned short SWIGSTDCALL CSharp_Dali_Uint16Pair_GetY(void * jarg1) {
9236   unsigned short jresult ;
9237   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9238   uint16_t result;
9239
9240   arg1 = (Dali::Uint16Pair *)jarg1;
9241   {
9242     try {
9243       result = ((Dali::Uint16Pair const *)arg1)->GetY();
9244     } catch (std::out_of_range& e) {
9245       {
9246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9247       };
9248     } catch (std::exception& e) {
9249       {
9250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9251       };
9252     } catch (Dali::DaliException e) {
9253       {
9254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9255       };
9256     } catch (...) {
9257       {
9258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9259       };
9260     }
9261   }
9262
9263   jresult = result;
9264   return jresult;
9265 }
9266
9267
9268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Uint16Pair_Assign(void * jarg1, void * jarg2) {
9269   void * jresult ;
9270   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9271   Dali::Uint16Pair *arg2 = 0 ;
9272   Dali::Uint16Pair *result = 0 ;
9273
9274   arg1 = (Dali::Uint16Pair *)jarg1;
9275   arg2 = (Dali::Uint16Pair *)jarg2;
9276   if (!arg2) {
9277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9278     return 0;
9279   }
9280   {
9281     try {
9282       result = (Dali::Uint16Pair *) &(arg1)->operator =((Dali::Uint16Pair const &)*arg2);
9283     } catch (std::out_of_range& e) {
9284       {
9285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9286       };
9287     } catch (std::exception& e) {
9288       {
9289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9290       };
9291     } catch (Dali::DaliException e) {
9292       {
9293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9294       };
9295     } catch (...) {
9296       {
9297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9298       };
9299     }
9300   }
9301
9302   jresult = (void *)result;
9303   return jresult;
9304 }
9305
9306
9307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_EqualTo(void * jarg1, void * jarg2) {
9308   unsigned int jresult ;
9309   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9310   Dali::Uint16Pair *arg2 = 0 ;
9311   bool result;
9312
9313   arg1 = (Dali::Uint16Pair *)jarg1;
9314   arg2 = (Dali::Uint16Pair *)jarg2;
9315   if (!arg2) {
9316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9317     return 0;
9318   }
9319   {
9320     try {
9321       result = (bool)((Dali::Uint16Pair const *)arg1)->operator ==((Dali::Uint16Pair const &)*arg2);
9322     } catch (std::out_of_range& e) {
9323       {
9324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9325       };
9326     } catch (std::exception& e) {
9327       {
9328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9329       };
9330     } catch (Dali::DaliException e) {
9331       {
9332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9333       };
9334     } catch (...) {
9335       {
9336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9337       };
9338     }
9339   }
9340
9341   jresult = result;
9342   return jresult;
9343 }
9344
9345
9346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_NotEqualTo(void * jarg1, void * jarg2) {
9347   unsigned int jresult ;
9348   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9349   Dali::Uint16Pair *arg2 = 0 ;
9350   bool result;
9351
9352   arg1 = (Dali::Uint16Pair *)jarg1;
9353   arg2 = (Dali::Uint16Pair *)jarg2;
9354   if (!arg2) {
9355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9356     return 0;
9357   }
9358   {
9359     try {
9360       result = (bool)((Dali::Uint16Pair const *)arg1)->operator !=((Dali::Uint16Pair const &)*arg2);
9361     } catch (std::out_of_range& e) {
9362       {
9363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9364       };
9365     } catch (std::exception& e) {
9366       {
9367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9368       };
9369     } catch (Dali::DaliException e) {
9370       {
9371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9372       };
9373     } catch (...) {
9374       {
9375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9376       };
9377     }
9378   }
9379
9380   jresult = result;
9381   return jresult;
9382 }
9383
9384
9385 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_LessThan(void * jarg1, void * jarg2) {
9386   unsigned int jresult ;
9387   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9388   Dali::Uint16Pair *arg2 = 0 ;
9389   bool result;
9390
9391   arg1 = (Dali::Uint16Pair *)jarg1;
9392   arg2 = (Dali::Uint16Pair *)jarg2;
9393   if (!arg2) {
9394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9395     return 0;
9396   }
9397   {
9398     try {
9399       result = (bool)((Dali::Uint16Pair const *)arg1)->operator <((Dali::Uint16Pair const &)*arg2);
9400     } catch (std::out_of_range& e) {
9401       {
9402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9403       };
9404     } catch (std::exception& e) {
9405       {
9406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9407       };
9408     } catch (Dali::DaliException e) {
9409       {
9410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9411       };
9412     } catch (...) {
9413       {
9414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9415       };
9416     }
9417   }
9418
9419   jresult = result;
9420   return jresult;
9421 }
9422
9423
9424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Uint16Pair_GreaterThan(void * jarg1, void * jarg2) {
9425   unsigned int jresult ;
9426   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9427   Dali::Uint16Pair *arg2 = 0 ;
9428   bool result;
9429
9430   arg1 = (Dali::Uint16Pair *)jarg1;
9431   arg2 = (Dali::Uint16Pair *)jarg2;
9432   if (!arg2) {
9433     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Uint16Pair const & type is null", 0);
9434     return 0;
9435   }
9436   {
9437     try {
9438       result = (bool)((Dali::Uint16Pair const *)arg1)->operator >((Dali::Uint16Pair const &)*arg2);
9439     } catch (std::out_of_range& e) {
9440       {
9441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9442       };
9443     } catch (std::exception& e) {
9444       {
9445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9446       };
9447     } catch (Dali::DaliException e) {
9448       {
9449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9450       };
9451     } catch (...) {
9452       {
9453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9454       };
9455     }
9456   }
9457
9458   jresult = result;
9459   return jresult;
9460 }
9461
9462
9463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Uint16Pair(void * jarg1) {
9464   Dali::Uint16Pair *arg1 = (Dali::Uint16Pair *) 0 ;
9465
9466   arg1 = (Dali::Uint16Pair *)jarg1;
9467   {
9468     try {
9469       delete arg1;
9470     } catch (std::out_of_range& e) {
9471       {
9472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9473       };
9474     } catch (std::exception& e) {
9475       {
9476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9477       };
9478     } catch (Dali::DaliException e) {
9479       {
9480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9481       };
9482     } catch (...) {
9483       {
9484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9485       };
9486     }
9487   }
9488
9489 }
9490
9491
9492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_0() {
9493   void * jresult ;
9494   Dali::Degree *result = 0 ;
9495
9496   {
9497     try {
9498       result = (Dali::Degree *)new Dali::Degree();
9499     } catch (std::out_of_range& e) {
9500       {
9501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9502       };
9503     } catch (std::exception& e) {
9504       {
9505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9506       };
9507     } catch (Dali::DaliException e) {
9508       {
9509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9510       };
9511     } catch (...) {
9512       {
9513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9514       };
9515     }
9516   }
9517
9518   jresult = (void *)result;
9519   return jresult;
9520 }
9521
9522
9523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_1(float jarg1) {
9524   void * jresult ;
9525   float arg1 ;
9526   Dali::Degree *result = 0 ;
9527
9528   arg1 = (float)jarg1;
9529   {
9530     try {
9531       result = (Dali::Degree *)new Dali::Degree(arg1);
9532     } catch (std::out_of_range& e) {
9533       {
9534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9535       };
9536     } catch (std::exception& e) {
9537       {
9538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9539       };
9540     } catch (Dali::DaliException e) {
9541       {
9542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9543       };
9544     } catch (...) {
9545       {
9546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9547       };
9548     }
9549   }
9550
9551   jresult = (void *)result;
9552   return jresult;
9553 }
9554
9555
9556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Degree__SWIG_2(void * jarg1) {
9557   void * jresult ;
9558   Dali::Radian arg1 ;
9559   Dali::Radian *argp1 ;
9560   Dali::Degree *result = 0 ;
9561
9562   argp1 = (Dali::Radian *)jarg1;
9563   if (!argp1) {
9564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
9565     return 0;
9566   }
9567   arg1 = *argp1;
9568   {
9569     try {
9570       result = (Dali::Degree *)new Dali::Degree(arg1);
9571     } catch (std::out_of_range& e) {
9572       {
9573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9574       };
9575     } catch (std::exception& e) {
9576       {
9577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9578       };
9579     } catch (Dali::DaliException e) {
9580       {
9581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9582       };
9583     } catch (...) {
9584       {
9585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9586       };
9587     }
9588   }
9589
9590   jresult = (void *)result;
9591   return jresult;
9592 }
9593
9594
9595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Degree_degree_set(void * jarg1, float jarg2) {
9596   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9597   float arg2 ;
9598
9599   arg1 = (Dali::Degree *)jarg1;
9600   arg2 = (float)jarg2;
9601   if (arg1) (arg1)->degree = arg2;
9602 }
9603
9604
9605 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Degree_degree_get(void * jarg1) {
9606   float jresult ;
9607   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9608   float result;
9609
9610   arg1 = (Dali::Degree *)jarg1;
9611   result = (float) ((arg1)->degree);
9612   jresult = result;
9613   return jresult;
9614 }
9615
9616
9617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Degree(void * jarg1) {
9618   Dali::Degree *arg1 = (Dali::Degree *) 0 ;
9619
9620   arg1 = (Dali::Degree *)jarg1;
9621   {
9622     try {
9623       delete arg1;
9624     } catch (std::out_of_range& e) {
9625       {
9626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
9627       };
9628     } catch (std::exception& e) {
9629       {
9630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
9631       };
9632     } catch (Dali::DaliException e) {
9633       {
9634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
9635       };
9636     } catch (...) {
9637       {
9638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
9639       };
9640     }
9641   }
9642
9643 }
9644
9645
9646 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_360_get() {
9647   void * jresult ;
9648   Dali::Radian *result = 0 ;
9649
9650   result = (Dali::Radian *)&Dali::ANGLE_360;
9651   jresult = (void *)result;
9652   return jresult;
9653 }
9654
9655
9656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_315_get() {
9657   void * jresult ;
9658   Dali::Radian *result = 0 ;
9659
9660   result = (Dali::Radian *)&Dali::ANGLE_315;
9661   jresult = (void *)result;
9662   return jresult;
9663 }
9664
9665
9666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_270_get() {
9667   void * jresult ;
9668   Dali::Radian *result = 0 ;
9669
9670   result = (Dali::Radian *)&Dali::ANGLE_270;
9671   jresult = (void *)result;
9672   return jresult;
9673 }
9674
9675
9676 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_225_get() {
9677   void * jresult ;
9678   Dali::Radian *result = 0 ;
9679
9680   result = (Dali::Radian *)&Dali::ANGLE_225;
9681   jresult = (void *)result;
9682   return jresult;
9683 }
9684
9685
9686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_180_get() {
9687   void * jresult ;
9688   Dali::Radian *result = 0 ;
9689
9690   result = (Dali::Radian *)&Dali::ANGLE_180;
9691   jresult = (void *)result;
9692   return jresult;
9693 }
9694
9695
9696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_135_get() {
9697   void * jresult ;
9698   Dali::Radian *result = 0 ;
9699
9700   result = (Dali::Radian *)&Dali::ANGLE_135;
9701   jresult = (void *)result;
9702   return jresult;
9703 }
9704
9705
9706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_120_get() {
9707   void * jresult ;
9708   Dali::Radian *result = 0 ;
9709
9710   result = (Dali::Radian *)&Dali::ANGLE_120;
9711   jresult = (void *)result;
9712   return jresult;
9713 }
9714
9715
9716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_90_get() {
9717   void * jresult ;
9718   Dali::Radian *result = 0 ;
9719
9720   result = (Dali::Radian *)&Dali::ANGLE_90;
9721   jresult = (void *)result;
9722   return jresult;
9723 }
9724
9725
9726 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_60_get() {
9727   void * jresult ;
9728   Dali::Radian *result = 0 ;
9729
9730   result = (Dali::Radian *)&Dali::ANGLE_60;
9731   jresult = (void *)result;
9732   return jresult;
9733 }
9734
9735
9736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_45_get() {
9737   void * jresult ;
9738   Dali::Radian *result = 0 ;
9739
9740   result = (Dali::Radian *)&Dali::ANGLE_45;
9741   jresult = (void *)result;
9742   return jresult;
9743 }
9744
9745
9746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_30_get() {
9747   void * jresult ;
9748   Dali::Radian *result = 0 ;
9749
9750   result = (Dali::Radian *)&Dali::ANGLE_30;
9751   jresult = (void *)result;
9752   return jresult;
9753 }
9754
9755
9756 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ANGLE_0_get() {
9757   void * jresult ;
9758   Dali::Radian *result = 0 ;
9759
9760   result = (Dali::Radian *)&Dali::ANGLE_0;
9761   jresult = (void *)result;
9762   return jresult;
9763 }
9764
9765
9766 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_5(void * jarg1, void * jarg2) {
9767   unsigned int jresult ;
9768   Dali::Degree *arg1 = 0 ;
9769   Dali::Degree *arg2 = 0 ;
9770   bool result;
9771
9772   arg1 = (Dali::Degree *)jarg1;
9773   if (!arg1) {
9774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9775     return 0;
9776   }
9777   arg2 = (Dali::Degree *)jarg2;
9778   if (!arg2) {
9779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9780     return 0;
9781   }
9782   {
9783     try {
9784       result = (bool)Dali::operator ==((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9785     } catch (std::out_of_range& e) {
9786       {
9787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9788       };
9789     } catch (std::exception& e) {
9790       {
9791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9792       };
9793     } catch (Dali::DaliException e) {
9794       {
9795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9796       };
9797     } catch (...) {
9798       {
9799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9800       };
9801     }
9802   }
9803
9804   jresult = result;
9805   return jresult;
9806 }
9807
9808
9809 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_4(void * jarg1, void * jarg2) {
9810   unsigned int jresult ;
9811   Dali::Degree *arg1 = 0 ;
9812   Dali::Degree *arg2 = 0 ;
9813   bool result;
9814
9815   arg1 = (Dali::Degree *)jarg1;
9816   if (!arg1) {
9817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9818     return 0;
9819   }
9820   arg2 = (Dali::Degree *)jarg2;
9821   if (!arg2) {
9822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
9823     return 0;
9824   }
9825   {
9826     try {
9827       result = (bool)Dali::operator !=((Dali::Degree const &)*arg1,(Dali::Degree const &)*arg2);
9828     } catch (std::out_of_range& e) {
9829       {
9830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9831       };
9832     } catch (std::exception& e) {
9833       {
9834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9835       };
9836     } catch (Dali::DaliException e) {
9837       {
9838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9839       };
9840     } catch (...) {
9841       {
9842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9843       };
9844     }
9845   }
9846
9847   jresult = result;
9848   return jresult;
9849 }
9850
9851
9852 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3) {
9853   void * jresult ;
9854   Dali::Degree arg1 ;
9855   float arg2 ;
9856   float arg3 ;
9857   Dali::Degree *argp1 ;
9858   Dali::Degree result;
9859
9860   argp1 = (Dali::Degree *)jarg1;
9861   if (!argp1) {
9862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9863     return 0;
9864   }
9865   arg1 = *argp1;
9866   arg2 = (float)jarg2;
9867   arg3 = (float)jarg3;
9868   {
9869     try {
9870       result = Dali::Clamp(arg1,arg2,arg3);
9871     } catch (std::out_of_range& e) {
9872       {
9873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9874       };
9875     } catch (std::exception& e) {
9876       {
9877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9878       };
9879     } catch (Dali::DaliException e) {
9880       {
9881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9882       };
9883     } catch (...) {
9884       {
9885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9886       };
9887     }
9888   }
9889
9890   jresult = new Dali::Degree((const Dali::Degree &)result);
9891   return jresult;
9892 }
9893
9894
9895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_0() {
9896   void * jresult ;
9897   Dali::Radian *result = 0 ;
9898
9899   {
9900     try {
9901       result = (Dali::Radian *)new Dali::Radian();
9902     } catch (std::out_of_range& e) {
9903       {
9904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9905       };
9906     } catch (std::exception& e) {
9907       {
9908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9909       };
9910     } catch (Dali::DaliException e) {
9911       {
9912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9913       };
9914     } catch (...) {
9915       {
9916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9917       };
9918     }
9919   }
9920
9921   jresult = (void *)result;
9922   return jresult;
9923 }
9924
9925
9926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_1(float jarg1) {
9927   void * jresult ;
9928   float arg1 ;
9929   Dali::Radian *result = 0 ;
9930
9931   arg1 = (float)jarg1;
9932   {
9933     try {
9934       result = (Dali::Radian *)new Dali::Radian(arg1);
9935     } catch (std::out_of_range& e) {
9936       {
9937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9938       };
9939     } catch (std::exception& e) {
9940       {
9941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9942       };
9943     } catch (Dali::DaliException e) {
9944       {
9945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9946       };
9947     } catch (...) {
9948       {
9949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9950       };
9951     }
9952   }
9953
9954   jresult = (void *)result;
9955   return jresult;
9956 }
9957
9958
9959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Radian__SWIG_2(void * jarg1) {
9960   void * jresult ;
9961   Dali::Degree arg1 ;
9962   Dali::Degree *argp1 ;
9963   Dali::Radian *result = 0 ;
9964
9965   argp1 = (Dali::Degree *)jarg1;
9966   if (!argp1) {
9967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
9968     return 0;
9969   }
9970   arg1 = *argp1;
9971   {
9972     try {
9973       result = (Dali::Radian *)new Dali::Radian(arg1);
9974     } catch (std::out_of_range& e) {
9975       {
9976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
9977       };
9978     } catch (std::exception& e) {
9979       {
9980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
9981       };
9982     } catch (Dali::DaliException e) {
9983       {
9984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
9985       };
9986     } catch (...) {
9987       {
9988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
9989       };
9990     }
9991   }
9992
9993   jresult = (void *)result;
9994   return jresult;
9995 }
9996
9997
9998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_0(void * jarg1, float jarg2) {
9999   void * jresult ;
10000   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10001   float arg2 ;
10002   Dali::Radian *result = 0 ;
10003
10004   arg1 = (Dali::Radian *)jarg1;
10005   arg2 = (float)jarg2;
10006   {
10007     try {
10008       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10009     } catch (std::out_of_range& e) {
10010       {
10011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10012       };
10013     } catch (std::exception& e) {
10014       {
10015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10016       };
10017     } catch (Dali::DaliException e) {
10018       {
10019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10020       };
10021     } catch (...) {
10022       {
10023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10024       };
10025     }
10026   }
10027
10028   jresult = (void *)result;
10029   return jresult;
10030 }
10031
10032
10033 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Radian_Assign__SWIG_1(void * jarg1, void * jarg2) {
10034   void * jresult ;
10035   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10036   Dali::Degree arg2 ;
10037   Dali::Degree *argp2 ;
10038   Dali::Radian *result = 0 ;
10039
10040   arg1 = (Dali::Radian *)jarg1;
10041   argp2 = (Dali::Degree *)jarg2;
10042   if (!argp2) {
10043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10044     return 0;
10045   }
10046   arg2 = *argp2;
10047   {
10048     try {
10049       result = (Dali::Radian *) &(arg1)->operator =(arg2);
10050     } catch (std::out_of_range& e) {
10051       {
10052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10053       };
10054     } catch (std::exception& e) {
10055       {
10056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10057       };
10058     } catch (Dali::DaliException e) {
10059       {
10060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10061       };
10062     } catch (...) {
10063       {
10064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10065       };
10066     }
10067   }
10068
10069   jresult = (void *)result;
10070   return jresult;
10071 }
10072
10073
10074 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_ConvertToFloat(void * jarg1) {
10075   float jresult ;
10076   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10077   float result;
10078
10079   arg1 = (Dali::Radian *)jarg1;
10080   {
10081     try {
10082       result = (float)((Dali::Radian const *)arg1)->operator float();
10083     } catch (std::out_of_range& e) {
10084       {
10085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10086       };
10087     } catch (std::exception& e) {
10088       {
10089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10090       };
10091     } catch (Dali::DaliException e) {
10092       {
10093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10094       };
10095     } catch (...) {
10096       {
10097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10098       };
10099     }
10100   }
10101
10102   jresult = result;
10103   return jresult;
10104 }
10105
10106
10107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Radian_radian_set(void * jarg1, float jarg2) {
10108   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10109   float arg2 ;
10110
10111   arg1 = (Dali::Radian *)jarg1;
10112   arg2 = (float)jarg2;
10113   if (arg1) (arg1)->radian = arg2;
10114 }
10115
10116
10117 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Radian_radian_get(void * jarg1) {
10118   float jresult ;
10119   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10120   float result;
10121
10122   arg1 = (Dali::Radian *)jarg1;
10123   result = (float) ((arg1)->radian);
10124   jresult = result;
10125   return jresult;
10126 }
10127
10128
10129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Radian(void * jarg1) {
10130   Dali::Radian *arg1 = (Dali::Radian *) 0 ;
10131
10132   arg1 = (Dali::Radian *)jarg1;
10133   {
10134     try {
10135       delete arg1;
10136     } catch (std::out_of_range& e) {
10137       {
10138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10139       };
10140     } catch (std::exception& e) {
10141       {
10142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10143       };
10144     } catch (Dali::DaliException e) {
10145       {
10146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10147       };
10148     } catch (...) {
10149       {
10150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10151       };
10152     }
10153   }
10154
10155 }
10156
10157
10158 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_6(void * jarg1, void * jarg2) {
10159   unsigned int jresult ;
10160   Dali::Radian arg1 ;
10161   Dali::Radian arg2 ;
10162   Dali::Radian *argp1 ;
10163   Dali::Radian *argp2 ;
10164   bool result;
10165
10166   argp1 = (Dali::Radian *)jarg1;
10167   if (!argp1) {
10168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10169     return 0;
10170   }
10171   arg1 = *argp1;
10172   argp2 = (Dali::Radian *)jarg2;
10173   if (!argp2) {
10174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10175     return 0;
10176   }
10177   arg2 = *argp2;
10178   {
10179     try {
10180       result = (bool)Dali::operator ==(arg1,arg2);
10181     } catch (std::out_of_range& e) {
10182       {
10183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10184       };
10185     } catch (std::exception& e) {
10186       {
10187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10188       };
10189     } catch (Dali::DaliException e) {
10190       {
10191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10192       };
10193     } catch (...) {
10194       {
10195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10196       };
10197     }
10198   }
10199
10200   jresult = result;
10201   return jresult;
10202 }
10203
10204
10205 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_5(void * jarg1, void * jarg2) {
10206   unsigned int jresult ;
10207   Dali::Radian arg1 ;
10208   Dali::Radian arg2 ;
10209   Dali::Radian *argp1 ;
10210   Dali::Radian *argp2 ;
10211   bool result;
10212
10213   argp1 = (Dali::Radian *)jarg1;
10214   if (!argp1) {
10215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10216     return 0;
10217   }
10218   arg1 = *argp1;
10219   argp2 = (Dali::Radian *)jarg2;
10220   if (!argp2) {
10221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10222     return 0;
10223   }
10224   arg2 = *argp2;
10225   {
10226     try {
10227       result = (bool)Dali::operator !=(arg1,arg2);
10228     } catch (std::out_of_range& e) {
10229       {
10230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10231       };
10232     } catch (std::exception& e) {
10233       {
10234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10235       };
10236     } catch (Dali::DaliException e) {
10237       {
10238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10239       };
10240     } catch (...) {
10241       {
10242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10243       };
10244     }
10245   }
10246
10247   jresult = result;
10248   return jresult;
10249 }
10250
10251
10252 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_7(void * jarg1, void * jarg2) {
10253   unsigned int jresult ;
10254   Dali::Radian arg1 ;
10255   Dali::Degree arg2 ;
10256   Dali::Radian *argp1 ;
10257   Dali::Degree *argp2 ;
10258   bool result;
10259
10260   argp1 = (Dali::Radian *)jarg1;
10261   if (!argp1) {
10262     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10263     return 0;
10264   }
10265   arg1 = *argp1;
10266   argp2 = (Dali::Degree *)jarg2;
10267   if (!argp2) {
10268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10269     return 0;
10270   }
10271   arg2 = *argp2;
10272   {
10273     try {
10274       result = (bool)Dali::operator ==(arg1,arg2);
10275     } catch (std::out_of_range& e) {
10276       {
10277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10278       };
10279     } catch (std::exception& e) {
10280       {
10281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10282       };
10283     } catch (Dali::DaliException e) {
10284       {
10285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10286       };
10287     } catch (...) {
10288       {
10289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10290       };
10291     }
10292   }
10293
10294   jresult = result;
10295   return jresult;
10296 }
10297
10298
10299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_6(void * jarg1, void * jarg2) {
10300   unsigned int jresult ;
10301   Dali::Radian arg1 ;
10302   Dali::Degree arg2 ;
10303   Dali::Radian *argp1 ;
10304   Dali::Degree *argp2 ;
10305   bool result;
10306
10307   argp1 = (Dali::Radian *)jarg1;
10308   if (!argp1) {
10309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10310     return 0;
10311   }
10312   arg1 = *argp1;
10313   argp2 = (Dali::Degree *)jarg2;
10314   if (!argp2) {
10315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10316     return 0;
10317   }
10318   arg2 = *argp2;
10319   {
10320     try {
10321       result = (bool)Dali::operator !=(arg1,arg2);
10322     } catch (std::out_of_range& e) {
10323       {
10324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10325       };
10326     } catch (std::exception& e) {
10327       {
10328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10329       };
10330     } catch (Dali::DaliException e) {
10331       {
10332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10333       };
10334     } catch (...) {
10335       {
10336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10337       };
10338     }
10339   }
10340
10341   jresult = result;
10342   return jresult;
10343 }
10344
10345
10346 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_8(void * jarg1, void * jarg2) {
10347   unsigned int jresult ;
10348   Dali::Degree arg1 ;
10349   Dali::Radian arg2 ;
10350   Dali::Degree *argp1 ;
10351   Dali::Radian *argp2 ;
10352   bool result;
10353
10354   argp1 = (Dali::Degree *)jarg1;
10355   if (!argp1) {
10356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10357     return 0;
10358   }
10359   arg1 = *argp1;
10360   argp2 = (Dali::Radian *)jarg2;
10361   if (!argp2) {
10362     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10363     return 0;
10364   }
10365   arg2 = *argp2;
10366   {
10367     try {
10368       result = (bool)Dali::operator ==(arg1,arg2);
10369     } catch (std::out_of_range& e) {
10370       {
10371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10372       };
10373     } catch (std::exception& e) {
10374       {
10375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10376       };
10377     } catch (Dali::DaliException e) {
10378       {
10379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10380       };
10381     } catch (...) {
10382       {
10383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10384       };
10385     }
10386   }
10387
10388   jresult = result;
10389   return jresult;
10390 }
10391
10392
10393 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NotEqualTo__SWIG_7(void * jarg1, void * jarg2) {
10394   unsigned int jresult ;
10395   Dali::Degree arg1 ;
10396   Dali::Radian arg2 ;
10397   Dali::Degree *argp1 ;
10398   Dali::Radian *argp2 ;
10399   bool result;
10400
10401   argp1 = (Dali::Degree *)jarg1;
10402   if (!argp1) {
10403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10404     return 0;
10405   }
10406   arg1 = *argp1;
10407   argp2 = (Dali::Radian *)jarg2;
10408   if (!argp2) {
10409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10410     return 0;
10411   }
10412   arg2 = *argp2;
10413   {
10414     try {
10415       result = (bool)Dali::operator !=(arg1,arg2);
10416     } catch (std::out_of_range& e) {
10417       {
10418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10419       };
10420     } catch (std::exception& e) {
10421       {
10422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10423       };
10424     } catch (Dali::DaliException e) {
10425       {
10426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10427       };
10428     } catch (...) {
10429       {
10430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10431       };
10432     }
10433   }
10434
10435   jresult = result;
10436   return jresult;
10437 }
10438
10439
10440 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_0(void * jarg1, void * jarg2) {
10441   unsigned int jresult ;
10442   Dali::Radian arg1 ;
10443   Dali::Radian arg2 ;
10444   Dali::Radian *argp1 ;
10445   Dali::Radian *argp2 ;
10446   bool result;
10447
10448   argp1 = (Dali::Radian *)jarg1;
10449   if (!argp1) {
10450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10451     return 0;
10452   }
10453   arg1 = *argp1;
10454   argp2 = (Dali::Radian *)jarg2;
10455   if (!argp2) {
10456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10457     return 0;
10458   }
10459   arg2 = *argp2;
10460   {
10461     try {
10462       result = (bool)Dali::operator >(arg1,arg2);
10463     } catch (std::out_of_range& e) {
10464       {
10465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10466       };
10467     } catch (std::exception& e) {
10468       {
10469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10470       };
10471     } catch (Dali::DaliException e) {
10472       {
10473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10474       };
10475     } catch (...) {
10476       {
10477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10478       };
10479     }
10480   }
10481
10482   jresult = result;
10483   return jresult;
10484 }
10485
10486
10487 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_1(void * jarg1, void * jarg2) {
10488   unsigned int jresult ;
10489   Dali::Radian arg1 ;
10490   Dali::Degree arg2 ;
10491   Dali::Radian *argp1 ;
10492   Dali::Degree *argp2 ;
10493   bool result;
10494
10495   argp1 = (Dali::Radian *)jarg1;
10496   if (!argp1) {
10497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10498     return 0;
10499   }
10500   arg1 = *argp1;
10501   argp2 = (Dali::Degree *)jarg2;
10502   if (!argp2) {
10503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10504     return 0;
10505   }
10506   arg2 = *argp2;
10507   {
10508     try {
10509       result = (bool)Dali::operator >(arg1,arg2);
10510     } catch (std::out_of_range& e) {
10511       {
10512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10513       };
10514     } catch (std::exception& e) {
10515       {
10516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10517       };
10518     } catch (Dali::DaliException e) {
10519       {
10520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10521       };
10522     } catch (...) {
10523       {
10524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10525       };
10526     }
10527   }
10528
10529   jresult = result;
10530   return jresult;
10531 }
10532
10533
10534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GreaterThan__SWIG_2(void * jarg1, void * jarg2) {
10535   unsigned int jresult ;
10536   Dali::Degree arg1 ;
10537   Dali::Radian arg2 ;
10538   Dali::Degree *argp1 ;
10539   Dali::Radian *argp2 ;
10540   bool result;
10541
10542   argp1 = (Dali::Degree *)jarg1;
10543   if (!argp1) {
10544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10545     return 0;
10546   }
10547   arg1 = *argp1;
10548   argp2 = (Dali::Radian *)jarg2;
10549   if (!argp2) {
10550     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10551     return 0;
10552   }
10553   arg2 = *argp2;
10554   {
10555     try {
10556       result = (bool)Dali::operator >(arg1,arg2);
10557     } catch (std::out_of_range& e) {
10558       {
10559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10560       };
10561     } catch (std::exception& e) {
10562       {
10563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10564       };
10565     } catch (Dali::DaliException e) {
10566       {
10567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10568       };
10569     } catch (...) {
10570       {
10571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10572       };
10573     }
10574   }
10575
10576   jresult = result;
10577   return jresult;
10578 }
10579
10580
10581 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_0(void * jarg1, void * jarg2) {
10582   unsigned int jresult ;
10583   Dali::Radian arg1 ;
10584   Dali::Radian arg2 ;
10585   Dali::Radian *argp1 ;
10586   Dali::Radian *argp2 ;
10587   bool result;
10588
10589   argp1 = (Dali::Radian *)jarg1;
10590   if (!argp1) {
10591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10592     return 0;
10593   }
10594   arg1 = *argp1;
10595   argp2 = (Dali::Radian *)jarg2;
10596   if (!argp2) {
10597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10598     return 0;
10599   }
10600   arg2 = *argp2;
10601   {
10602     try {
10603       result = (bool)Dali::operator <(arg1,arg2);
10604     } catch (std::out_of_range& e) {
10605       {
10606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10607       };
10608     } catch (std::exception& e) {
10609       {
10610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10611       };
10612     } catch (Dali::DaliException e) {
10613       {
10614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10615       };
10616     } catch (...) {
10617       {
10618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10619       };
10620     }
10621   }
10622
10623   jresult = result;
10624   return jresult;
10625 }
10626
10627
10628 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_1(void * jarg1, void * jarg2) {
10629   unsigned int jresult ;
10630   Dali::Radian arg1 ;
10631   Dali::Degree arg2 ;
10632   Dali::Radian *argp1 ;
10633   Dali::Degree *argp2 ;
10634   bool result;
10635
10636   argp1 = (Dali::Radian *)jarg1;
10637   if (!argp1) {
10638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10639     return 0;
10640   }
10641   arg1 = *argp1;
10642   argp2 = (Dali::Degree *)jarg2;
10643   if (!argp2) {
10644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10645     return 0;
10646   }
10647   arg2 = *argp2;
10648   {
10649     try {
10650       result = (bool)Dali::operator <(arg1,arg2);
10651     } catch (std::out_of_range& e) {
10652       {
10653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10654       };
10655     } catch (std::exception& e) {
10656       {
10657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10658       };
10659     } catch (Dali::DaliException e) {
10660       {
10661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10662       };
10663     } catch (...) {
10664       {
10665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10666       };
10667     }
10668   }
10669
10670   jresult = result;
10671   return jresult;
10672 }
10673
10674
10675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_2(void * jarg1, void * jarg2) {
10676   unsigned int jresult ;
10677   Dali::Degree arg1 ;
10678   Dali::Radian arg2 ;
10679   Dali::Degree *argp1 ;
10680   Dali::Radian *argp2 ;
10681   bool result;
10682
10683   argp1 = (Dali::Degree *)jarg1;
10684   if (!argp1) {
10685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Degree", 0);
10686     return 0;
10687   }
10688   arg1 = *argp1;
10689   argp2 = (Dali::Radian *)jarg2;
10690   if (!argp2) {
10691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10692     return 0;
10693   }
10694   arg2 = *argp2;
10695   {
10696     try {
10697       result = (bool)Dali::operator <(arg1,arg2);
10698     } catch (std::out_of_range& e) {
10699       {
10700         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10701       };
10702     } catch (std::exception& e) {
10703       {
10704         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10705       };
10706     } catch (Dali::DaliException e) {
10707       {
10708         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10709       };
10710     } catch (...) {
10711       {
10712         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10713       };
10714     }
10715   }
10716
10717   jresult = result;
10718   return jresult;
10719 }
10720
10721
10722 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Multiply(void * jarg1, float jarg2) {
10723   void * jresult ;
10724   Dali::Radian arg1 ;
10725   float arg2 ;
10726   Dali::Radian *argp1 ;
10727   Dali::Radian result;
10728
10729   argp1 = (Dali::Radian *)jarg1;
10730   if (!argp1) {
10731     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10732     return 0;
10733   }
10734   arg1 = *argp1;
10735   arg2 = (float)jarg2;
10736   {
10737     try {
10738       result = Dali::operator *(arg1,arg2);
10739     } catch (std::out_of_range& e) {
10740       {
10741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10742       };
10743     } catch (std::exception& e) {
10744       {
10745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10746       };
10747     } catch (Dali::DaliException e) {
10748       {
10749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10750       };
10751     } catch (...) {
10752       {
10753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10754       };
10755     }
10756   }
10757
10758   jresult = new Dali::Radian((const Dali::Radian &)result);
10759   return jresult;
10760 }
10761
10762
10763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Subtract(void * jarg1) {
10764   void * jresult ;
10765   Dali::Radian arg1 ;
10766   Dali::Radian *argp1 ;
10767   Dali::Radian result;
10768
10769   argp1 = (Dali::Radian *)jarg1;
10770   if (!argp1) {
10771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10772     return 0;
10773   }
10774   arg1 = *argp1;
10775   {
10776     try {
10777       result = Dali::operator -(arg1);
10778     } catch (std::out_of_range& e) {
10779       {
10780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10781       };
10782     } catch (std::exception& e) {
10783       {
10784         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10785       };
10786     } catch (Dali::DaliException e) {
10787       {
10788         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10789       };
10790     } catch (...) {
10791       {
10792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10793       };
10794     }
10795   }
10796
10797   jresult = new Dali::Radian((const Dali::Radian &)result);
10798   return jresult;
10799 }
10800
10801
10802 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Clamp__SWIG_4(void * jarg1, float jarg2, float jarg3) {
10803   void * jresult ;
10804   Dali::Radian arg1 ;
10805   float arg2 ;
10806   float arg3 ;
10807   Dali::Radian *argp1 ;
10808   Dali::Radian result;
10809
10810   argp1 = (Dali::Radian *)jarg1;
10811   if (!argp1) {
10812     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10813     return 0;
10814   }
10815   arg1 = *argp1;
10816   arg2 = (float)jarg2;
10817   arg3 = (float)jarg3;
10818   {
10819     try {
10820       result = Dali::Clamp(arg1,arg2,arg3);
10821     } catch (std::out_of_range& e) {
10822       {
10823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10824       };
10825     } catch (std::exception& e) {
10826       {
10827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10828       };
10829     } catch (Dali::DaliException e) {
10830       {
10831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10832       };
10833     } catch (...) {
10834       {
10835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10836       };
10837     }
10838   }
10839
10840   jresult = new Dali::Radian((const Dali::Radian &)result);
10841   return jresult;
10842 }
10843
10844
10845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_0() {
10846   void * jresult ;
10847   Dali::Quaternion *result = 0 ;
10848
10849   {
10850     try {
10851       result = (Dali::Quaternion *)new Dali::Quaternion();
10852     } catch (std::out_of_range& e) {
10853       {
10854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10855       };
10856     } catch (std::exception& e) {
10857       {
10858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10859       };
10860     } catch (Dali::DaliException e) {
10861       {
10862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10863       };
10864     } catch (...) {
10865       {
10866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10867       };
10868     }
10869   }
10870
10871   jresult = (void *)result;
10872   return jresult;
10873 }
10874
10875
10876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rotation__SWIG_1(void * jarg1, void * jarg2) {
10877   void * jresult ;
10878   Dali::Radian arg1 ;
10879   Dali::Vector3 *arg2 = 0 ;
10880   Dali::Radian *argp1 ;
10881   Dali::Quaternion *result = 0 ;
10882
10883   argp1 = (Dali::Radian *)jarg1;
10884   if (!argp1) {
10885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
10886     return 0;
10887   }
10888   arg1 = *argp1;
10889   arg2 = (Dali::Vector3 *)jarg2;
10890   if (!arg2) {
10891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
10892     return 0;
10893   }
10894   {
10895     try {
10896       result = (Dali::Quaternion *)new Dali::Quaternion(arg1,(Dali::Vector3 const &)*arg2);
10897     } catch (std::out_of_range& e) {
10898       {
10899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10900       };
10901     } catch (std::exception& e) {
10902       {
10903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10904       };
10905     } catch (Dali::DaliException e) {
10906       {
10907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10908       };
10909     } catch (...) {
10910       {
10911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10912       };
10913     }
10914   }
10915
10916   jresult = (void *)result;
10917   return jresult;
10918 }
10919
10920
10921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rotation(void * jarg1) {
10922   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10923
10924   arg1 = (Dali::Quaternion *)jarg1;
10925   {
10926     try {
10927       delete arg1;
10928     } catch (std::out_of_range& e) {
10929       {
10930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
10931       };
10932     } catch (std::exception& e) {
10933       {
10934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
10935       };
10936     } catch (Dali::DaliException e) {
10937       {
10938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
10939       };
10940     } catch (...) {
10941       {
10942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
10943       };
10944     }
10945   }
10946
10947 }
10948
10949
10950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_IDENTITY_get() {
10951   void * jresult ;
10952   Dali::Quaternion *result = 0 ;
10953
10954   result = (Dali::Quaternion *)&Dali::Quaternion::IDENTITY;
10955   jresult = (void *)result;
10956   return jresult;
10957 }
10958
10959
10960 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_IsIdentity(void * jarg1) {
10961   unsigned int jresult ;
10962   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10963   bool result;
10964
10965   arg1 = (Dali::Quaternion *)jarg1;
10966   {
10967     try {
10968       result = (bool)((Dali::Quaternion const *)arg1)->IsIdentity();
10969     } catch (std::out_of_range& e) {
10970       {
10971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
10972       };
10973     } catch (std::exception& e) {
10974       {
10975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
10976       };
10977     } catch (Dali::DaliException e) {
10978       {
10979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
10980       };
10981     } catch (...) {
10982       {
10983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
10984       };
10985     }
10986   }
10987
10988   jresult = result;
10989   return jresult;
10990 }
10991
10992
10993 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_GetAxisAngle(void * jarg1, void * jarg2, void * jarg3) {
10994   unsigned int jresult ;
10995   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
10996   Dali::Vector3 *arg2 = 0 ;
10997   Dali::Radian *arg3 = 0 ;
10998   bool result;
10999
11000   arg1 = (Dali::Quaternion *)jarg1;
11001   arg2 = (Dali::Vector3 *)jarg2;
11002   if (!arg2) {
11003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
11004     return 0;
11005   }
11006   arg3 = (Dali::Radian *)jarg3;
11007   if (!arg3) {
11008     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian & type is null", 0);
11009     return 0;
11010   }
11011   {
11012     try {
11013       result = (bool)((Dali::Quaternion const *)arg1)->ToAxisAngle(*arg2,*arg3);
11014     } catch (std::out_of_range& e) {
11015       {
11016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11017       };
11018     } catch (std::exception& e) {
11019       {
11020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11021       };
11022     } catch (Dali::DaliException e) {
11023       {
11024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11025       };
11026     } catch (...) {
11027       {
11028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11029       };
11030     }
11031   }
11032
11033   jresult = result;
11034   return jresult;
11035 }
11036
11037
11038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Add(void * jarg1, void * jarg2) {
11039   void * jresult ;
11040   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11041   Dali::Quaternion *arg2 = 0 ;
11042   Dali::Quaternion result;
11043
11044   arg1 = (Dali::Quaternion *)jarg1;
11045   arg2 = (Dali::Quaternion *)jarg2;
11046   if (!arg2) {
11047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11048     return 0;
11049   }
11050   {
11051     try {
11052       result = ((Dali::Quaternion const *)arg1)->operator +((Dali::Quaternion const &)*arg2);
11053     } catch (std::out_of_range& e) {
11054       {
11055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11056       };
11057     } catch (std::exception& e) {
11058       {
11059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11060       };
11061     } catch (Dali::DaliException e) {
11062       {
11063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11064       };
11065     } catch (...) {
11066       {
11067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11068       };
11069     }
11070   }
11071
11072   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11073   return jresult;
11074 }
11075
11076
11077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_0(void * jarg1, void * jarg2) {
11078   void * jresult ;
11079   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11080   Dali::Quaternion *arg2 = 0 ;
11081   Dali::Quaternion result;
11082
11083   arg1 = (Dali::Quaternion *)jarg1;
11084   arg2 = (Dali::Quaternion *)jarg2;
11085   if (!arg2) {
11086     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11087     return 0;
11088   }
11089   {
11090     try {
11091       result = ((Dali::Quaternion const *)arg1)->operator -((Dali::Quaternion const &)*arg2);
11092     } catch (std::out_of_range& e) {
11093       {
11094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11095       };
11096     } catch (std::exception& e) {
11097       {
11098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11099       };
11100     } catch (Dali::DaliException e) {
11101       {
11102         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11103       };
11104     } catch (...) {
11105       {
11106         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11107       };
11108     }
11109   }
11110
11111   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11112   return jresult;
11113 }
11114
11115
11116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_0(void * jarg1, void * jarg2) {
11117   void * jresult ;
11118   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11119   Dali::Quaternion *arg2 = 0 ;
11120   Dali::Quaternion result;
11121
11122   arg1 = (Dali::Quaternion *)jarg1;
11123   arg2 = (Dali::Quaternion *)jarg2;
11124   if (!arg2) {
11125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11126     return 0;
11127   }
11128   {
11129     try {
11130       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Quaternion const &)*arg2);
11131     } catch (std::out_of_range& e) {
11132       {
11133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11134       };
11135     } catch (std::exception& e) {
11136       {
11137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11138       };
11139     } catch (Dali::DaliException e) {
11140       {
11141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11142       };
11143     } catch (...) {
11144       {
11145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11146       };
11147     }
11148   }
11149
11150   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11151   return jresult;
11152 }
11153
11154
11155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_1(void * jarg1, void * jarg2) {
11156   void * jresult ;
11157   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11158   Dali::Vector3 *arg2 = 0 ;
11159   Dali::Vector3 result;
11160
11161   arg1 = (Dali::Quaternion *)jarg1;
11162   arg2 = (Dali::Vector3 *)jarg2;
11163   if (!arg2) {
11164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
11165     return 0;
11166   }
11167   {
11168     try {
11169       result = ((Dali::Quaternion const *)arg1)->operator *((Dali::Vector3 const &)*arg2);
11170     } catch (std::out_of_range& e) {
11171       {
11172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11173       };
11174     } catch (std::exception& e) {
11175       {
11176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11177       };
11178     } catch (Dali::DaliException e) {
11179       {
11180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11181       };
11182     } catch (...) {
11183       {
11184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11185       };
11186     }
11187   }
11188
11189   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
11190   return jresult;
11191 }
11192
11193
11194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_0(void * jarg1, void * jarg2) {
11195   void * jresult ;
11196   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11197   Dali::Quaternion *arg2 = 0 ;
11198   Dali::Quaternion result;
11199
11200   arg1 = (Dali::Quaternion *)jarg1;
11201   arg2 = (Dali::Quaternion *)jarg2;
11202   if (!arg2) {
11203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11204     return 0;
11205   }
11206   {
11207     try {
11208       result = ((Dali::Quaternion const *)arg1)->operator /((Dali::Quaternion const &)*arg2);
11209     } catch (std::out_of_range& e) {
11210       {
11211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11212       };
11213     } catch (std::exception& e) {
11214       {
11215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11216       };
11217     } catch (Dali::DaliException e) {
11218       {
11219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11220       };
11221     } catch (...) {
11222       {
11223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11224       };
11225     }
11226   }
11227
11228   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11229   return jresult;
11230 }
11231
11232
11233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Multiply__SWIG_2(void * jarg1, float jarg2) {
11234   void * jresult ;
11235   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11236   float arg2 ;
11237   Dali::Quaternion result;
11238
11239   arg1 = (Dali::Quaternion *)jarg1;
11240   arg2 = (float)jarg2;
11241   {
11242     try {
11243       result = ((Dali::Quaternion const *)arg1)->operator *(arg2);
11244     } catch (std::out_of_range& e) {
11245       {
11246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11247       };
11248     } catch (std::exception& e) {
11249       {
11250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11251       };
11252     } catch (Dali::DaliException e) {
11253       {
11254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11255       };
11256     } catch (...) {
11257       {
11258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11259       };
11260     }
11261   }
11262
11263   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11264   return jresult;
11265 }
11266
11267
11268 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Divide__SWIG_1(void * jarg1, float jarg2) {
11269   void * jresult ;
11270   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11271   float arg2 ;
11272   Dali::Quaternion result;
11273
11274   arg1 = (Dali::Quaternion *)jarg1;
11275   arg2 = (float)jarg2;
11276   {
11277     try {
11278       result = ((Dali::Quaternion const *)arg1)->operator /(arg2);
11279     } catch (std::out_of_range& e) {
11280       {
11281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11282       };
11283     } catch (std::exception& e) {
11284       {
11285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11286       };
11287     } catch (Dali::DaliException e) {
11288       {
11289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11290       };
11291     } catch (...) {
11292       {
11293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11294       };
11295     }
11296   }
11297
11298   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11299   return jresult;
11300 }
11301
11302
11303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Subtract__SWIG_1(void * jarg1) {
11304   void * jresult ;
11305   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11306   Dali::Quaternion result;
11307
11308   arg1 = (Dali::Quaternion *)jarg1;
11309   {
11310     try {
11311       result = ((Dali::Quaternion const *)arg1)->operator -();
11312     } catch (std::out_of_range& e) {
11313       {
11314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11315       };
11316     } catch (std::exception& e) {
11317       {
11318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11319       };
11320     } catch (Dali::DaliException e) {
11321       {
11322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11323       };
11324     } catch (...) {
11325       {
11326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11327       };
11328     }
11329   }
11330
11331   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11332   return jresult;
11333 }
11334
11335
11336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_AddAssign(void * jarg1, void * jarg2) {
11337   void * jresult ;
11338   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11339   Dali::Quaternion *arg2 = 0 ;
11340   Dali::Quaternion *result = 0 ;
11341
11342   arg1 = (Dali::Quaternion *)jarg1;
11343   arg2 = (Dali::Quaternion *)jarg2;
11344   if (!arg2) {
11345     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11346     return 0;
11347   }
11348   {
11349     try {
11350       result = (Dali::Quaternion *) &(arg1)->operator +=((Dali::Quaternion const &)*arg2);
11351     } catch (std::out_of_range& e) {
11352       {
11353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11354       };
11355     } catch (std::exception& e) {
11356       {
11357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11358       };
11359     } catch (Dali::DaliException e) {
11360       {
11361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11362       };
11363     } catch (...) {
11364       {
11365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11366       };
11367     }
11368   }
11369
11370   jresult = (void *)result;
11371   return jresult;
11372 }
11373
11374
11375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SubtractAssign(void * jarg1, void * jarg2) {
11376   void * jresult ;
11377   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11378   Dali::Quaternion *arg2 = 0 ;
11379   Dali::Quaternion *result = 0 ;
11380
11381   arg1 = (Dali::Quaternion *)jarg1;
11382   arg2 = (Dali::Quaternion *)jarg2;
11383   if (!arg2) {
11384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11385     return 0;
11386   }
11387   {
11388     try {
11389       result = (Dali::Quaternion *) &(arg1)->operator -=((Dali::Quaternion const &)*arg2);
11390     } catch (std::out_of_range& e) {
11391       {
11392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11393       };
11394     } catch (std::exception& e) {
11395       {
11396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11397       };
11398     } catch (Dali::DaliException e) {
11399       {
11400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11401       };
11402     } catch (...) {
11403       {
11404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11405       };
11406     }
11407   }
11408
11409   jresult = (void *)result;
11410   return jresult;
11411 }
11412
11413
11414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_0(void * jarg1, void * jarg2) {
11415   void * jresult ;
11416   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11417   Dali::Quaternion *arg2 = 0 ;
11418   Dali::Quaternion *result = 0 ;
11419
11420   arg1 = (Dali::Quaternion *)jarg1;
11421   arg2 = (Dali::Quaternion *)jarg2;
11422   if (!arg2) {
11423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11424     return 0;
11425   }
11426   {
11427     try {
11428       result = (Dali::Quaternion *) &(arg1)->operator *=((Dali::Quaternion const &)*arg2);
11429     } catch (std::out_of_range& e) {
11430       {
11431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11432       };
11433     } catch (std::exception& e) {
11434       {
11435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11436       };
11437     } catch (Dali::DaliException e) {
11438       {
11439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11440       };
11441     } catch (...) {
11442       {
11443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11444       };
11445     }
11446   }
11447
11448   jresult = (void *)result;
11449   return jresult;
11450 }
11451
11452
11453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_MultiplyAssign__SWIG_1(void * jarg1, float jarg2) {
11454   void * jresult ;
11455   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11456   float arg2 ;
11457   Dali::Quaternion *result = 0 ;
11458
11459   arg1 = (Dali::Quaternion *)jarg1;
11460   arg2 = (float)jarg2;
11461   {
11462     try {
11463       result = (Dali::Quaternion *) &(arg1)->operator *=(arg2);
11464     } catch (std::out_of_range& e) {
11465       {
11466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11467       };
11468     } catch (std::exception& e) {
11469       {
11470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11471       };
11472     } catch (Dali::DaliException e) {
11473       {
11474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11475       };
11476     } catch (...) {
11477       {
11478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11479       };
11480     }
11481   }
11482
11483   jresult = (void *)result;
11484   return jresult;
11485 }
11486
11487
11488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_DivideAssign(void * jarg1, float jarg2) {
11489   void * jresult ;
11490   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11491   float arg2 ;
11492   Dali::Quaternion *result = 0 ;
11493
11494   arg1 = (Dali::Quaternion *)jarg1;
11495   arg2 = (float)jarg2;
11496   {
11497     try {
11498       result = (Dali::Quaternion *) &(arg1)->operator /=(arg2);
11499     } catch (std::out_of_range& e) {
11500       {
11501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11502       };
11503     } catch (std::exception& e) {
11504       {
11505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11506       };
11507     } catch (Dali::DaliException e) {
11508       {
11509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11510       };
11511     } catch (...) {
11512       {
11513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11514       };
11515     }
11516   }
11517
11518   jresult = (void *)result;
11519   return jresult;
11520 }
11521
11522
11523 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_EqualTo(void * jarg1, void * jarg2) {
11524   unsigned int jresult ;
11525   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11526   Dali::Quaternion *arg2 = 0 ;
11527   bool result;
11528
11529   arg1 = (Dali::Quaternion *)jarg1;
11530   arg2 = (Dali::Quaternion *)jarg2;
11531   if (!arg2) {
11532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11533     return 0;
11534   }
11535   {
11536     try {
11537       result = (bool)((Dali::Quaternion const *)arg1)->operator ==((Dali::Quaternion const &)*arg2);
11538     } catch (std::out_of_range& e) {
11539       {
11540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11541       };
11542     } catch (std::exception& e) {
11543       {
11544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11545       };
11546     } catch (Dali::DaliException e) {
11547       {
11548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11549       };
11550     } catch (...) {
11551       {
11552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11553       };
11554     }
11555   }
11556
11557   jresult = result;
11558   return jresult;
11559 }
11560
11561
11562 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rotation_NotEqualTo(void * jarg1, void * jarg2) {
11563   unsigned int jresult ;
11564   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11565   Dali::Quaternion *arg2 = 0 ;
11566   bool result;
11567
11568   arg1 = (Dali::Quaternion *)jarg1;
11569   arg2 = (Dali::Quaternion *)jarg2;
11570   if (!arg2) {
11571     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11572     return 0;
11573   }
11574   {
11575     try {
11576       result = (bool)((Dali::Quaternion const *)arg1)->operator !=((Dali::Quaternion const &)*arg2);
11577     } catch (std::out_of_range& e) {
11578       {
11579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11580       };
11581     } catch (std::exception& e) {
11582       {
11583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11584       };
11585     } catch (Dali::DaliException e) {
11586       {
11587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11588       };
11589     } catch (...) {
11590       {
11591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11592       };
11593     }
11594   }
11595
11596   jresult = result;
11597   return jresult;
11598 }
11599
11600
11601 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Length(void * jarg1) {
11602   float jresult ;
11603   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11604   float result;
11605
11606   arg1 = (Dali::Quaternion *)jarg1;
11607   {
11608     try {
11609       result = (float)((Dali::Quaternion const *)arg1)->Length();
11610     } catch (std::out_of_range& e) {
11611       {
11612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11613       };
11614     } catch (std::exception& e) {
11615       {
11616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11617       };
11618     } catch (Dali::DaliException e) {
11619       {
11620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11621       };
11622     } catch (...) {
11623       {
11624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11625       };
11626     }
11627   }
11628
11629   jresult = result;
11630   return jresult;
11631 }
11632
11633
11634 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_LengthSquared(void * jarg1) {
11635   float jresult ;
11636   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11637   float result;
11638
11639   arg1 = (Dali::Quaternion *)jarg1;
11640   {
11641     try {
11642       result = (float)((Dali::Quaternion const *)arg1)->LengthSquared();
11643     } catch (std::out_of_range& e) {
11644       {
11645         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11646       };
11647     } catch (std::exception& e) {
11648       {
11649         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11650       };
11651     } catch (Dali::DaliException e) {
11652       {
11653         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11654       };
11655     } catch (...) {
11656       {
11657         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11658       };
11659     }
11660   }
11661
11662   jresult = result;
11663   return jresult;
11664 }
11665
11666
11667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Normalize(void * jarg1) {
11668   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11669
11670   arg1 = (Dali::Quaternion *)jarg1;
11671   {
11672     try {
11673       (arg1)->Normalize();
11674     } catch (std::out_of_range& e) {
11675       {
11676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11677       };
11678     } catch (std::exception& e) {
11679       {
11680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11681       };
11682     } catch (Dali::DaliException e) {
11683       {
11684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11685       };
11686     } catch (...) {
11687       {
11688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11689       };
11690     }
11691   }
11692
11693 }
11694
11695
11696 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Normalized(void * jarg1) {
11697   void * jresult ;
11698   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11699   Dali::Quaternion result;
11700
11701   arg1 = (Dali::Quaternion *)jarg1;
11702   {
11703     try {
11704       result = ((Dali::Quaternion const *)arg1)->Normalized();
11705     } catch (std::out_of_range& e) {
11706       {
11707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11708       };
11709     } catch (std::exception& e) {
11710       {
11711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11712       };
11713     } catch (Dali::DaliException e) {
11714       {
11715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11716       };
11717     } catch (...) {
11718       {
11719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11720       };
11721     }
11722   }
11723
11724   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11725   return jresult;
11726 }
11727
11728
11729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Conjugate(void * jarg1) {
11730   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11731
11732   arg1 = (Dali::Quaternion *)jarg1;
11733   {
11734     try {
11735       (arg1)->Conjugate();
11736     } catch (std::out_of_range& e) {
11737       {
11738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11739       };
11740     } catch (std::exception& e) {
11741       {
11742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11743       };
11744     } catch (Dali::DaliException e) {
11745       {
11746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11747       };
11748     } catch (...) {
11749       {
11750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11751       };
11752     }
11753   }
11754
11755 }
11756
11757
11758 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rotation_Invert(void * jarg1) {
11759   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11760
11761   arg1 = (Dali::Quaternion *)jarg1;
11762   {
11763     try {
11764       (arg1)->Invert();
11765     } catch (std::out_of_range& e) {
11766       {
11767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
11768       };
11769     } catch (std::exception& e) {
11770       {
11771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
11772       };
11773     } catch (Dali::DaliException e) {
11774       {
11775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
11776       };
11777     } catch (...) {
11778       {
11779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
11780       };
11781     }
11782   }
11783
11784 }
11785
11786
11787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Log(void * jarg1) {
11788   void * jresult ;
11789   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11790   Dali::Quaternion result;
11791
11792   arg1 = (Dali::Quaternion *)jarg1;
11793   {
11794     try {
11795       result = ((Dali::Quaternion const *)arg1)->Log();
11796     } catch (std::out_of_range& e) {
11797       {
11798         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11799       };
11800     } catch (std::exception& e) {
11801       {
11802         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11803       };
11804     } catch (Dali::DaliException e) {
11805       {
11806         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11807       };
11808     } catch (...) {
11809       {
11810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11811       };
11812     }
11813   }
11814
11815   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11816   return jresult;
11817 }
11818
11819
11820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Exp(void * jarg1) {
11821   void * jresult ;
11822   Dali::Quaternion *arg1 = (Dali::Quaternion *) 0 ;
11823   Dali::Quaternion result;
11824
11825   arg1 = (Dali::Quaternion *)jarg1;
11826   {
11827     try {
11828       result = ((Dali::Quaternion const *)arg1)->Exp();
11829     } catch (std::out_of_range& e) {
11830       {
11831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11832       };
11833     } catch (std::exception& e) {
11834       {
11835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11836       };
11837     } catch (Dali::DaliException e) {
11838       {
11839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11840       };
11841     } catch (...) {
11842       {
11843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11844       };
11845     }
11846   }
11847
11848   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11849   return jresult;
11850 }
11851
11852
11853 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_Dot(void * jarg1, void * jarg2) {
11854   float jresult ;
11855   Dali::Quaternion *arg1 = 0 ;
11856   Dali::Quaternion *arg2 = 0 ;
11857   float result;
11858
11859   arg1 = (Dali::Quaternion *)jarg1;
11860   if (!arg1) {
11861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11862     return 0;
11863   }
11864   arg2 = (Dali::Quaternion *)jarg2;
11865   if (!arg2) {
11866     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11867     return 0;
11868   }
11869   {
11870     try {
11871       result = (float)Dali::Quaternion::Dot((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
11872     } catch (std::out_of_range& e) {
11873       {
11874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11875       };
11876     } catch (std::exception& e) {
11877       {
11878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11879       };
11880     } catch (Dali::DaliException e) {
11881       {
11882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11883       };
11884     } catch (...) {
11885       {
11886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11887       };
11888     }
11889   }
11890
11891   jresult = result;
11892   return jresult;
11893 }
11894
11895
11896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Lerp(void * jarg1, void * jarg2, float jarg3) {
11897   void * jresult ;
11898   Dali::Quaternion *arg1 = 0 ;
11899   Dali::Quaternion *arg2 = 0 ;
11900   float arg3 ;
11901   Dali::Quaternion result;
11902
11903   arg1 = (Dali::Quaternion *)jarg1;
11904   if (!arg1) {
11905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11906     return 0;
11907   }
11908   arg2 = (Dali::Quaternion *)jarg2;
11909   if (!arg2) {
11910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11911     return 0;
11912   }
11913   arg3 = (float)jarg3;
11914   {
11915     try {
11916       result = Dali::Quaternion::Lerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11917     } catch (std::out_of_range& e) {
11918       {
11919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11920       };
11921     } catch (std::exception& e) {
11922       {
11923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11924       };
11925     } catch (Dali::DaliException e) {
11926       {
11927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11928       };
11929     } catch (...) {
11930       {
11931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11932       };
11933     }
11934   }
11935
11936   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11937   return jresult;
11938 }
11939
11940
11941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Slerp(void * jarg1, void * jarg2, float jarg3) {
11942   void * jresult ;
11943   Dali::Quaternion *arg1 = 0 ;
11944   Dali::Quaternion *arg2 = 0 ;
11945   float arg3 ;
11946   Dali::Quaternion result;
11947
11948   arg1 = (Dali::Quaternion *)jarg1;
11949   if (!arg1) {
11950     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11951     return 0;
11952   }
11953   arg2 = (Dali::Quaternion *)jarg2;
11954   if (!arg2) {
11955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11956     return 0;
11957   }
11958   arg3 = (float)jarg3;
11959   {
11960     try {
11961       result = Dali::Quaternion::Slerp((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
11962     } catch (std::out_of_range& e) {
11963       {
11964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
11965       };
11966     } catch (std::exception& e) {
11967       {
11968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
11969       };
11970     } catch (Dali::DaliException e) {
11971       {
11972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
11973       };
11974     } catch (...) {
11975       {
11976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
11977       };
11978     }
11979   }
11980
11981   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
11982   return jresult;
11983 }
11984
11985
11986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_SlerpNoInvert(void * jarg1, void * jarg2, float jarg3) {
11987   void * jresult ;
11988   Dali::Quaternion *arg1 = 0 ;
11989   Dali::Quaternion *arg2 = 0 ;
11990   float arg3 ;
11991   Dali::Quaternion result;
11992
11993   arg1 = (Dali::Quaternion *)jarg1;
11994   if (!arg1) {
11995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
11996     return 0;
11997   }
11998   arg2 = (Dali::Quaternion *)jarg2;
11999   if (!arg2) {
12000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12001     return 0;
12002   }
12003   arg3 = (float)jarg3;
12004   {
12005     try {
12006       result = Dali::Quaternion::SlerpNoInvert((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,arg3);
12007     } catch (std::out_of_range& e) {
12008       {
12009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12010       };
12011     } catch (std::exception& e) {
12012       {
12013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12014       };
12015     } catch (Dali::DaliException e) {
12016       {
12017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12018       };
12019     } catch (...) {
12020       {
12021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12022       };
12023     }
12024   }
12025
12026   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12027   return jresult;
12028 }
12029
12030
12031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rotation_Squad(void * jarg1, void * jarg2, void * jarg3, void * jarg4, float jarg5) {
12032   void * jresult ;
12033   Dali::Quaternion *arg1 = 0 ;
12034   Dali::Quaternion *arg2 = 0 ;
12035   Dali::Quaternion *arg3 = 0 ;
12036   Dali::Quaternion *arg4 = 0 ;
12037   float arg5 ;
12038   Dali::Quaternion result;
12039
12040   arg1 = (Dali::Quaternion *)jarg1;
12041   if (!arg1) {
12042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12043     return 0;
12044   }
12045   arg2 = (Dali::Quaternion *)jarg2;
12046   if (!arg2) {
12047     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12048     return 0;
12049   }
12050   arg3 = (Dali::Quaternion *)jarg3;
12051   if (!arg3) {
12052     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12053     return 0;
12054   }
12055   arg4 = (Dali::Quaternion *)jarg4;
12056   if (!arg4) {
12057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12058     return 0;
12059   }
12060   arg5 = (float)jarg5;
12061   {
12062     try {
12063       result = Dali::Quaternion::Squad((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Quaternion const &)*arg4,arg5);
12064     } catch (std::out_of_range& e) {
12065       {
12066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12067       };
12068     } catch (std::exception& e) {
12069       {
12070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12071       };
12072     } catch (Dali::DaliException e) {
12073       {
12074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12075       };
12076     } catch (...) {
12077       {
12078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12079       };
12080     }
12081   }
12082
12083   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
12084   return jresult;
12085 }
12086
12087
12088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Rotation_AngleBetween(void * jarg1, void * jarg2) {
12089   float jresult ;
12090   Dali::Quaternion *arg1 = 0 ;
12091   Dali::Quaternion *arg2 = 0 ;
12092   float 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   {
12105     try {
12106       result = (float)Dali::Quaternion::AngleBetween((Dali::Quaternion const &)*arg1,(Dali::Quaternion const &)*arg2);
12107     } catch (std::out_of_range& e) {
12108       {
12109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12110       };
12111     } catch (std::exception& e) {
12112       {
12113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12114       };
12115     } catch (Dali::DaliException e) {
12116       {
12117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12118       };
12119     } catch (...) {
12120       {
12121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12122       };
12123     }
12124   }
12125
12126   jresult = result;
12127   return jresult;
12128 }
12129
12130
12131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_0() {
12132   void * jresult ;
12133   Dali::Matrix *result = 0 ;
12134
12135   {
12136     try {
12137       result = (Dali::Matrix *)new Dali::Matrix();
12138     } catch (std::out_of_range& e) {
12139       {
12140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12141       };
12142     } catch (std::exception& e) {
12143       {
12144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12145       };
12146     } catch (Dali::DaliException e) {
12147       {
12148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12149       };
12150     } catch (...) {
12151       {
12152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12153       };
12154     }
12155   }
12156
12157   jresult = (void *)result;
12158   return jresult;
12159 }
12160
12161
12162 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_1(unsigned int jarg1) {
12163   void * jresult ;
12164   bool arg1 ;
12165   Dali::Matrix *result = 0 ;
12166
12167   arg1 = jarg1 ? true : false;
12168   {
12169     try {
12170       result = (Dali::Matrix *)new Dali::Matrix(arg1);
12171     } catch (std::out_of_range& e) {
12172       {
12173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12174       };
12175     } catch (std::exception& e) {
12176       {
12177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12178       };
12179     } catch (Dali::DaliException e) {
12180       {
12181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12182       };
12183     } catch (...) {
12184       {
12185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12186       };
12187     }
12188   }
12189
12190   jresult = (void *)result;
12191   return jresult;
12192 }
12193
12194
12195 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_2(float* jarg1) {
12196   void * jresult ;
12197   float *arg1 = (float *) 0 ;
12198   Dali::Matrix *result = 0 ;
12199
12200   arg1 = jarg1;
12201   {
12202     try {
12203       result = (Dali::Matrix *)new Dali::Matrix((float const *)arg1);
12204     } catch (std::out_of_range& e) {
12205       {
12206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12207       };
12208     } catch (std::exception& e) {
12209       {
12210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12211       };
12212     } catch (Dali::DaliException e) {
12213       {
12214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12215       };
12216     } catch (...) {
12217       {
12218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12219       };
12220     }
12221   }
12222
12223   jresult = (void *)result;
12224
12225
12226   return jresult;
12227 }
12228
12229
12230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_3(void * jarg1) {
12231   void * jresult ;
12232   Dali::Quaternion *arg1 = 0 ;
12233   Dali::Matrix *result = 0 ;
12234
12235   arg1 = (Dali::Quaternion *)jarg1;
12236   if (!arg1) {
12237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12238     return 0;
12239   }
12240   {
12241     try {
12242       result = (Dali::Matrix *)new Dali::Matrix((Dali::Quaternion const &)*arg1);
12243     } catch (std::out_of_range& e) {
12244       {
12245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12246       };
12247     } catch (std::exception& e) {
12248       {
12249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12250       };
12251     } catch (Dali::DaliException e) {
12252       {
12253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12254       };
12255     } catch (...) {
12256       {
12257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12258       };
12259     }
12260   }
12261
12262   jresult = (void *)result;
12263   return jresult;
12264 }
12265
12266
12267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix__SWIG_4(void * jarg1) {
12268   void * jresult ;
12269   Dali::Matrix *arg1 = 0 ;
12270   Dali::Matrix *result = 0 ;
12271
12272   arg1 = (Dali::Matrix *)jarg1;
12273   if (!arg1) {
12274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12275     return 0;
12276   }
12277   {
12278     try {
12279       result = (Dali::Matrix *)new Dali::Matrix((Dali::Matrix const &)*arg1);
12280     } catch (std::out_of_range& e) {
12281       {
12282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12283       };
12284     } catch (std::exception& e) {
12285       {
12286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12287       };
12288     } catch (Dali::DaliException e) {
12289       {
12290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12291       };
12292     } catch (...) {
12293       {
12294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12295       };
12296     }
12297   }
12298
12299   jresult = (void *)result;
12300   return jresult;
12301 }
12302
12303
12304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Assign(void * jarg1, void * jarg2) {
12305   void * jresult ;
12306   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12307   Dali::Matrix *arg2 = 0 ;
12308   Dali::Matrix *result = 0 ;
12309
12310   arg1 = (Dali::Matrix *)jarg1;
12311   arg2 = (Dali::Matrix *)jarg2;
12312   if (!arg2) {
12313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12314     return 0;
12315   }
12316   {
12317     try {
12318       result = (Dali::Matrix *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
12319     } catch (std::out_of_range& e) {
12320       {
12321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12322       };
12323     } catch (std::exception& e) {
12324       {
12325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12326       };
12327     } catch (Dali::DaliException e) {
12328       {
12329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12330       };
12331     } catch (...) {
12332       {
12333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12334       };
12335     }
12336   }
12337
12338   jresult = (void *)result;
12339   return jresult;
12340 }
12341
12342
12343 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_IDENTITY_get() {
12344   void * jresult ;
12345   Dali::Matrix *result = 0 ;
12346
12347   result = (Dali::Matrix *)&Dali::Matrix::IDENTITY;
12348   jresult = (void *)result;
12349   return jresult;
12350 }
12351
12352
12353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentity(void * jarg1) {
12354   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12355
12356   arg1 = (Dali::Matrix *)jarg1;
12357   {
12358     try {
12359       (arg1)->SetIdentity();
12360     } catch (std::out_of_range& e) {
12361       {
12362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12363       };
12364     } catch (std::exception& e) {
12365       {
12366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12367       };
12368     } catch (Dali::DaliException e) {
12369       {
12370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12371       };
12372     } catch (...) {
12373       {
12374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12375       };
12376     }
12377   }
12378
12379 }
12380
12381
12382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetIdentityAndScale(void * jarg1, void * jarg2) {
12383   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12384   Dali::Vector3 *arg2 = 0 ;
12385
12386   arg1 = (Dali::Matrix *)jarg1;
12387   arg2 = (Dali::Vector3 *)jarg2;
12388   if (!arg2) {
12389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12390     return ;
12391   }
12392   {
12393     try {
12394       (arg1)->SetIdentityAndScale((Dali::Vector3 const &)*arg2);
12395     } catch (std::out_of_range& e) {
12396       {
12397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12398       };
12399     } catch (std::exception& e) {
12400       {
12401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12402       };
12403     } catch (Dali::DaliException e) {
12404       {
12405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12406       };
12407     } catch (...) {
12408       {
12409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12410       };
12411     }
12412   }
12413
12414 }
12415
12416
12417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_InvertTransform(void * jarg1, void * jarg2) {
12418   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12419   Dali::Matrix *arg2 = 0 ;
12420
12421   arg1 = (Dali::Matrix *)jarg1;
12422   arg2 = (Dali::Matrix *)jarg2;
12423   if (!arg2) {
12424     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12425     return ;
12426   }
12427   {
12428     try {
12429       ((Dali::Matrix const *)arg1)->InvertTransform(*arg2);
12430     } catch (std::out_of_range& e) {
12431       {
12432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12433       };
12434     } catch (std::exception& e) {
12435       {
12436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12437       };
12438     } catch (Dali::DaliException e) {
12439       {
12440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12441       };
12442     } catch (...) {
12443       {
12444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12445       };
12446     }
12447   }
12448
12449 }
12450
12451
12452 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_Invert(void * jarg1) {
12453   unsigned int jresult ;
12454   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12455   bool result;
12456
12457   arg1 = (Dali::Matrix *)jarg1;
12458   {
12459     try {
12460       result = (bool)(arg1)->Invert();
12461     } catch (std::out_of_range& e) {
12462       {
12463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12464       };
12465     } catch (std::exception& e) {
12466       {
12467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12468       };
12469     } catch (Dali::DaliException e) {
12470       {
12471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12472       };
12473     } catch (...) {
12474       {
12475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12476       };
12477     }
12478   }
12479
12480   jresult = result;
12481   return jresult;
12482 }
12483
12484
12485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Transpose(void * jarg1) {
12486   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12487
12488   arg1 = (Dali::Matrix *)jarg1;
12489   {
12490     try {
12491       (arg1)->Transpose();
12492     } catch (std::out_of_range& e) {
12493       {
12494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12495       };
12496     } catch (std::exception& e) {
12497       {
12498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12499       };
12500     } catch (Dali::DaliException e) {
12501       {
12502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12503       };
12504     } catch (...) {
12505       {
12506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12507       };
12508     }
12509   }
12510
12511 }
12512
12513
12514 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetXAxis(void * jarg1) {
12515   void * jresult ;
12516   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12517   Dali::Vector3 result;
12518
12519   arg1 = (Dali::Matrix *)jarg1;
12520   {
12521     try {
12522       result = ((Dali::Matrix const *)arg1)->GetXAxis();
12523     } catch (std::out_of_range& e) {
12524       {
12525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12526       };
12527     } catch (std::exception& e) {
12528       {
12529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12530       };
12531     } catch (Dali::DaliException e) {
12532       {
12533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12534       };
12535     } catch (...) {
12536       {
12537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12538       };
12539     }
12540   }
12541
12542   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12543   return jresult;
12544 }
12545
12546
12547 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetYAxis(void * jarg1) {
12548   void * jresult ;
12549   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12550   Dali::Vector3 result;
12551
12552   arg1 = (Dali::Matrix *)jarg1;
12553   {
12554     try {
12555       result = ((Dali::Matrix const *)arg1)->GetYAxis();
12556     } catch (std::out_of_range& e) {
12557       {
12558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12559       };
12560     } catch (std::exception& e) {
12561       {
12562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12563       };
12564     } catch (Dali::DaliException e) {
12565       {
12566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12567       };
12568     } catch (...) {
12569       {
12570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12571       };
12572     }
12573   }
12574
12575   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12576   return jresult;
12577 }
12578
12579
12580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetZAxis(void * jarg1) {
12581   void * jresult ;
12582   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12583   Dali::Vector3 result;
12584
12585   arg1 = (Dali::Matrix *)jarg1;
12586   {
12587     try {
12588       result = ((Dali::Matrix const *)arg1)->GetZAxis();
12589     } catch (std::out_of_range& e) {
12590       {
12591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12592       };
12593     } catch (std::exception& e) {
12594       {
12595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12596       };
12597     } catch (Dali::DaliException e) {
12598       {
12599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12600       };
12601     } catch (...) {
12602       {
12603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12604       };
12605     }
12606   }
12607
12608   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
12609   return jresult;
12610 }
12611
12612
12613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetXAxis(void * jarg1, void * jarg2) {
12614   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12615   Dali::Vector3 *arg2 = 0 ;
12616
12617   arg1 = (Dali::Matrix *)jarg1;
12618   arg2 = (Dali::Vector3 *)jarg2;
12619   if (!arg2) {
12620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12621     return ;
12622   }
12623   {
12624     try {
12625       (arg1)->SetXAxis((Dali::Vector3 const &)*arg2);
12626     } catch (std::out_of_range& e) {
12627       {
12628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12629       };
12630     } catch (std::exception& e) {
12631       {
12632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12633       };
12634     } catch (Dali::DaliException e) {
12635       {
12636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12637       };
12638     } catch (...) {
12639       {
12640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12641       };
12642     }
12643   }
12644
12645 }
12646
12647
12648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetYAxis(void * jarg1, void * jarg2) {
12649   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12650   Dali::Vector3 *arg2 = 0 ;
12651
12652   arg1 = (Dali::Matrix *)jarg1;
12653   arg2 = (Dali::Vector3 *)jarg2;
12654   if (!arg2) {
12655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12656     return ;
12657   }
12658   {
12659     try {
12660       (arg1)->SetYAxis((Dali::Vector3 const &)*arg2);
12661     } catch (std::out_of_range& e) {
12662       {
12663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12664       };
12665     } catch (std::exception& e) {
12666       {
12667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12668       };
12669     } catch (Dali::DaliException e) {
12670       {
12671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12672       };
12673     } catch (...) {
12674       {
12675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12676       };
12677     }
12678   }
12679
12680 }
12681
12682
12683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetZAxis(void * jarg1, void * jarg2) {
12684   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12685   Dali::Vector3 *arg2 = 0 ;
12686
12687   arg1 = (Dali::Matrix *)jarg1;
12688   arg2 = (Dali::Vector3 *)jarg2;
12689   if (!arg2) {
12690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12691     return ;
12692   }
12693   {
12694     try {
12695       (arg1)->SetZAxis((Dali::Vector3 const &)*arg2);
12696     } catch (std::out_of_range& e) {
12697       {
12698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12699       };
12700     } catch (std::exception& e) {
12701       {
12702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12703       };
12704     } catch (Dali::DaliException e) {
12705       {
12706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12707       };
12708     } catch (...) {
12709       {
12710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12711       };
12712     }
12713   }
12714
12715 }
12716
12717
12718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation(void * jarg1) {
12719   void * jresult ;
12720   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12721   Dali::Vector4 *result = 0 ;
12722
12723   arg1 = (Dali::Matrix *)jarg1;
12724   {
12725     try {
12726       result = (Dali::Vector4 *) &((Dali::Matrix const *)arg1)->GetTranslation();
12727     } catch (std::out_of_range& e) {
12728       {
12729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12730       };
12731     } catch (std::exception& e) {
12732       {
12733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12734       };
12735     } catch (Dali::DaliException e) {
12736       {
12737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12738       };
12739     } catch (...) {
12740       {
12741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12742       };
12743     }
12744   }
12745
12746   jresult = (void *)result;
12747   return jresult;
12748 }
12749
12750
12751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_GetTranslation3(void * jarg1) {
12752   void * jresult ;
12753   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12754   Dali::Vector3 *result = 0 ;
12755
12756   arg1 = (Dali::Matrix *)jarg1;
12757   {
12758     try {
12759       result = (Dali::Vector3 *) &((Dali::Matrix const *)arg1)->GetTranslation3();
12760     } catch (std::out_of_range& e) {
12761       {
12762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12763       };
12764     } catch (std::exception& e) {
12765       {
12766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12767       };
12768     } catch (Dali::DaliException e) {
12769       {
12770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12771       };
12772     } catch (...) {
12773       {
12774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12775       };
12776     }
12777   }
12778
12779   jresult = (void *)result;
12780   return jresult;
12781 }
12782
12783
12784 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_0(void * jarg1, void * jarg2) {
12785   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12786   Dali::Vector4 *arg2 = 0 ;
12787
12788   arg1 = (Dali::Matrix *)jarg1;
12789   arg2 = (Dali::Vector4 *)jarg2;
12790   if (!arg2) {
12791     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
12792     return ;
12793   }
12794   {
12795     try {
12796       (arg1)->SetTranslation((Dali::Vector4 const &)*arg2);
12797     } catch (std::out_of_range& e) {
12798       {
12799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12800       };
12801     } catch (std::exception& e) {
12802       {
12803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12804       };
12805     } catch (Dali::DaliException e) {
12806       {
12807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12808       };
12809     } catch (...) {
12810       {
12811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12812       };
12813     }
12814   }
12815
12816 }
12817
12818
12819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTranslation__SWIG_1(void * jarg1, void * jarg2) {
12820   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12821   Dali::Vector3 *arg2 = 0 ;
12822
12823   arg1 = (Dali::Matrix *)jarg1;
12824   arg2 = (Dali::Vector3 *)jarg2;
12825   if (!arg2) {
12826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
12827     return ;
12828   }
12829   {
12830     try {
12831       (arg1)->SetTranslation((Dali::Vector3 const &)*arg2);
12832     } catch (std::out_of_range& e) {
12833       {
12834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12835       };
12836     } catch (std::exception& e) {
12837       {
12838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12839       };
12840     } catch (Dali::DaliException e) {
12841       {
12842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12843       };
12844     } catch (...) {
12845       {
12846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12847       };
12848     }
12849   }
12850
12851 }
12852
12853
12854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_OrthoNormalize(void * jarg1) {
12855   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12856
12857   arg1 = (Dali::Matrix *)jarg1;
12858   {
12859     try {
12860       (arg1)->OrthoNormalize();
12861     } catch (std::out_of_range& e) {
12862       {
12863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12864       };
12865     } catch (std::exception& e) {
12866       {
12867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12868       };
12869     } catch (Dali::DaliException e) {
12870       {
12871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12872       };
12873     } catch (...) {
12874       {
12875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12876       };
12877     }
12878   }
12879
12880 }
12881
12882
12883 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_AsFloat__SWIG_0(void * jarg1) {
12884   void * jresult ;
12885   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
12886   float *result = 0 ;
12887
12888   arg1 = (Dali::Matrix *)jarg1;
12889   {
12890     try {
12891       result = (float *)((Dali::Matrix const *)arg1)->AsFloat();
12892     } catch (std::out_of_range& e) {
12893       {
12894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
12895       };
12896     } catch (std::exception& e) {
12897       {
12898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
12899       };
12900     } catch (Dali::DaliException e) {
12901       {
12902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
12903       };
12904     } catch (...) {
12905       {
12906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
12907       };
12908     }
12909   }
12910
12911   jresult = (void *)result;
12912   return jresult;
12913 }
12914
12915
12916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
12917   Dali::Matrix *arg1 = 0 ;
12918   Dali::Matrix *arg2 = 0 ;
12919   Dali::Matrix *arg3 = 0 ;
12920
12921   arg1 = (Dali::Matrix *)jarg1;
12922   if (!arg1) {
12923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12924     return ;
12925   }
12926   arg2 = (Dali::Matrix *)jarg2;
12927   if (!arg2) {
12928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12929     return ;
12930   }
12931   arg3 = (Dali::Matrix *)jarg3;
12932   if (!arg3) {
12933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12934     return ;
12935   }
12936   {
12937     try {
12938       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Matrix const &)*arg3);
12939     } catch (std::out_of_range& e) {
12940       {
12941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12942       };
12943     } catch (std::exception& e) {
12944       {
12945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12946       };
12947     } catch (Dali::DaliException e) {
12948       {
12949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12950       };
12951     } catch (...) {
12952       {
12953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12954       };
12955     }
12956   }
12957
12958 }
12959
12960
12961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
12962   Dali::Matrix *arg1 = 0 ;
12963   Dali::Matrix *arg2 = 0 ;
12964   Dali::Quaternion *arg3 = 0 ;
12965
12966   arg1 = (Dali::Matrix *)jarg1;
12967   if (!arg1) {
12968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
12969     return ;
12970   }
12971   arg2 = (Dali::Matrix *)jarg2;
12972   if (!arg2) {
12973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
12974     return ;
12975   }
12976   arg3 = (Dali::Quaternion *)jarg3;
12977   if (!arg3) {
12978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
12979     return ;
12980   }
12981   {
12982     try {
12983       Dali::Matrix::Multiply(*arg1,(Dali::Matrix const &)*arg2,(Dali::Quaternion const &)*arg3);
12984     } catch (std::out_of_range& e) {
12985       {
12986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
12987       };
12988     } catch (std::exception& e) {
12989       {
12990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
12991       };
12992     } catch (Dali::DaliException e) {
12993       {
12994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
12995       };
12996     } catch (...) {
12997       {
12998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
12999       };
13000     }
13001   }
13002
13003 }
13004
13005
13006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix_Multiply__SWIG_2(void * jarg1, void * jarg2) {
13007   void * jresult ;
13008   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13009   Dali::Vector4 *arg2 = 0 ;
13010   Dali::Vector4 result;
13011
13012   arg1 = (Dali::Matrix *)jarg1;
13013   arg2 = (Dali::Vector4 *)jarg2;
13014   if (!arg2) {
13015     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
13016     return 0;
13017   }
13018   {
13019     try {
13020       result = ((Dali::Matrix const *)arg1)->operator *((Dali::Vector4 const &)*arg2);
13021     } catch (std::out_of_range& e) {
13022       {
13023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13024       };
13025     } catch (std::exception& e) {
13026       {
13027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13028       };
13029     } catch (Dali::DaliException e) {
13030       {
13031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13032       };
13033     } catch (...) {
13034       {
13035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13036       };
13037     }
13038   }
13039
13040   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
13041   return jresult;
13042 }
13043
13044
13045 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_EqualTo(void * jarg1, void * jarg2) {
13046   unsigned int jresult ;
13047   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13048   Dali::Matrix *arg2 = 0 ;
13049   bool result;
13050
13051   arg1 = (Dali::Matrix *)jarg1;
13052   arg2 = (Dali::Matrix *)jarg2;
13053   if (!arg2) {
13054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13055     return 0;
13056   }
13057   {
13058     try {
13059       result = (bool)((Dali::Matrix const *)arg1)->operator ==((Dali::Matrix const &)*arg2);
13060     } catch (std::out_of_range& e) {
13061       {
13062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13063       };
13064     } catch (std::exception& e) {
13065       {
13066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13067       };
13068     } catch (Dali::DaliException e) {
13069       {
13070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13071       };
13072     } catch (...) {
13073       {
13074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13075       };
13076     }
13077   }
13078
13079   jresult = result;
13080   return jresult;
13081 }
13082
13083
13084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix_NotEqualTo(void * jarg1, void * jarg2) {
13085   unsigned int jresult ;
13086   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13087   Dali::Matrix *arg2 = 0 ;
13088   bool result;
13089
13090   arg1 = (Dali::Matrix *)jarg1;
13091   arg2 = (Dali::Matrix *)jarg2;
13092   if (!arg2) {
13093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13094     return 0;
13095   }
13096   {
13097     try {
13098       result = (bool)((Dali::Matrix const *)arg1)->operator !=((Dali::Matrix const &)*arg2);
13099     } catch (std::out_of_range& e) {
13100       {
13101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13102       };
13103     } catch (std::exception& e) {
13104       {
13105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13106       };
13107     } catch (Dali::DaliException e) {
13108       {
13109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13110       };
13111     } catch (...) {
13112       {
13113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13114       };
13115     }
13116   }
13117
13118   jresult = result;
13119   return jresult;
13120 }
13121
13122
13123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13124   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13125   Dali::Vector3 *arg2 = 0 ;
13126   Dali::Quaternion *arg3 = 0 ;
13127   Dali::Vector3 *arg4 = 0 ;
13128
13129   arg1 = (Dali::Matrix *)jarg1;
13130   arg2 = (Dali::Vector3 *)jarg2;
13131   if (!arg2) {
13132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13133     return ;
13134   }
13135   arg3 = (Dali::Quaternion *)jarg3;
13136   if (!arg3) {
13137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13138     return ;
13139   }
13140   arg4 = (Dali::Vector3 *)jarg4;
13141   if (!arg4) {
13142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13143     return ;
13144   }
13145   {
13146     try {
13147       (arg1)->SetTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13148     } catch (std::out_of_range& e) {
13149       {
13150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13151       };
13152     } catch (std::exception& e) {
13153       {
13154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13155       };
13156     } catch (Dali::DaliException e) {
13157       {
13158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13159       };
13160     } catch (...) {
13161       {
13162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13163       };
13164     }
13165   }
13166
13167 }
13168
13169
13170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13171   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13172   Dali::Vector3 *arg2 = 0 ;
13173   Dali::Quaternion *arg3 = 0 ;
13174   Dali::Vector3 *arg4 = 0 ;
13175
13176   arg1 = (Dali::Matrix *)jarg1;
13177   arg2 = (Dali::Vector3 *)jarg2;
13178   if (!arg2) {
13179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13180     return ;
13181   }
13182   arg3 = (Dali::Quaternion *)jarg3;
13183   if (!arg3) {
13184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
13185     return ;
13186   }
13187   arg4 = (Dali::Vector3 *)jarg4;
13188   if (!arg4) {
13189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13190     return ;
13191   }
13192   {
13193     try {
13194       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Quaternion const &)*arg3,(Dali::Vector3 const &)*arg4);
13195     } catch (std::out_of_range& e) {
13196       {
13197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13198       };
13199     } catch (std::exception& e) {
13200       {
13201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13202       };
13203     } catch (Dali::DaliException e) {
13204       {
13205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13206       };
13207     } catch (...) {
13208       {
13209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13210       };
13211     }
13212   }
13213
13214 }
13215
13216
13217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_SetInverseTransformComponents__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
13218   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13219   Dali::Vector3 *arg2 = 0 ;
13220   Dali::Vector3 *arg3 = 0 ;
13221   Dali::Vector3 *arg4 = 0 ;
13222   Dali::Vector3 *arg5 = 0 ;
13223
13224   arg1 = (Dali::Matrix *)jarg1;
13225   arg2 = (Dali::Vector3 *)jarg2;
13226   if (!arg2) {
13227     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13228     return ;
13229   }
13230   arg3 = (Dali::Vector3 *)jarg3;
13231   if (!arg3) {
13232     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13233     return ;
13234   }
13235   arg4 = (Dali::Vector3 *)jarg4;
13236   if (!arg4) {
13237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13238     return ;
13239   }
13240   arg5 = (Dali::Vector3 *)jarg5;
13241   if (!arg5) {
13242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
13243     return ;
13244   }
13245   {
13246     try {
13247       (arg1)->SetInverseTransformComponents((Dali::Vector3 const &)*arg2,(Dali::Vector3 const &)*arg3,(Dali::Vector3 const &)*arg4,(Dali::Vector3 const &)*arg5);
13248     } catch (std::out_of_range& e) {
13249       {
13250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13251       };
13252     } catch (std::exception& e) {
13253       {
13254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13255       };
13256     } catch (Dali::DaliException e) {
13257       {
13258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13259       };
13260     } catch (...) {
13261       {
13262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13263       };
13264     }
13265   }
13266
13267 }
13268
13269
13270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix_GetTransformComponents(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
13271   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13272   Dali::Vector3 *arg2 = 0 ;
13273   Dali::Quaternion *arg3 = 0 ;
13274   Dali::Vector3 *arg4 = 0 ;
13275
13276   arg1 = (Dali::Matrix *)jarg1;
13277   arg2 = (Dali::Vector3 *)jarg2;
13278   if (!arg2) {
13279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13280     return ;
13281   }
13282   arg3 = (Dali::Quaternion *)jarg3;
13283   if (!arg3) {
13284     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
13285     return ;
13286   }
13287   arg4 = (Dali::Vector3 *)jarg4;
13288   if (!arg4) {
13289     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
13290     return ;
13291   }
13292   {
13293     try {
13294       ((Dali::Matrix const *)arg1)->GetTransformComponents(*arg2,*arg3,*arg4);
13295     } catch (std::out_of_range& e) {
13296       {
13297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13298       };
13299     } catch (std::exception& e) {
13300       {
13301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13302       };
13303     } catch (Dali::DaliException e) {
13304       {
13305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13306       };
13307     } catch (...) {
13308       {
13309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13310       };
13311     }
13312   }
13313
13314 }
13315
13316
13317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix(void * jarg1) {
13318   Dali::Matrix *arg1 = (Dali::Matrix *) 0 ;
13319
13320   arg1 = (Dali::Matrix *)jarg1;
13321   {
13322     try {
13323       delete arg1;
13324     } catch (std::out_of_range& e) {
13325       {
13326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13327       };
13328     } catch (std::exception& e) {
13329       {
13330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13331       };
13332     } catch (Dali::DaliException e) {
13333       {
13334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13335       };
13336     } catch (...) {
13337       {
13338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13339       };
13340     }
13341   }
13342
13343 }
13344
13345
13346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_IDENTITY_get() {
13347   void * jresult ;
13348   Dali::Matrix3 *result = 0 ;
13349
13350   result = (Dali::Matrix3 *)&Dali::Matrix3::IDENTITY;
13351   jresult = (void *)result;
13352   return jresult;
13353 }
13354
13355
13356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_0() {
13357   void * jresult ;
13358   Dali::Matrix3 *result = 0 ;
13359
13360   {
13361     try {
13362       result = (Dali::Matrix3 *)new Dali::Matrix3();
13363     } catch (std::out_of_range& e) {
13364       {
13365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13366       };
13367     } catch (std::exception& e) {
13368       {
13369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13370       };
13371     } catch (Dali::DaliException e) {
13372       {
13373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13374       };
13375     } catch (...) {
13376       {
13377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13378       };
13379     }
13380   }
13381
13382   jresult = (void *)result;
13383   return jresult;
13384 }
13385
13386
13387 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_1(void * jarg1) {
13388   void * jresult ;
13389   Dali::Matrix3 *arg1 = 0 ;
13390   Dali::Matrix3 *result = 0 ;
13391
13392   arg1 = (Dali::Matrix3 *)jarg1;
13393   if (!arg1) {
13394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13395     return 0;
13396   }
13397   {
13398     try {
13399       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix3 const &)*arg1);
13400     } catch (std::out_of_range& e) {
13401       {
13402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13403       };
13404     } catch (std::exception& e) {
13405       {
13406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13407       };
13408     } catch (Dali::DaliException e) {
13409       {
13410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13411       };
13412     } catch (...) {
13413       {
13414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13415       };
13416     }
13417   }
13418
13419   jresult = (void *)result;
13420   return jresult;
13421 }
13422
13423
13424 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Matrix3__SWIG_2(void * jarg1) {
13425   void * jresult ;
13426   Dali::Matrix *arg1 = 0 ;
13427   Dali::Matrix3 *result = 0 ;
13428
13429   arg1 = (Dali::Matrix *)jarg1;
13430   if (!arg1) {
13431     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13432     return 0;
13433   }
13434   {
13435     try {
13436       result = (Dali::Matrix3 *)new Dali::Matrix3((Dali::Matrix const &)*arg1);
13437     } catch (std::out_of_range& e) {
13438       {
13439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13440       };
13441     } catch (std::exception& e) {
13442       {
13443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13444       };
13445     } catch (Dali::DaliException e) {
13446       {
13447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13448       };
13449     } catch (...) {
13450       {
13451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13452       };
13453     }
13454   }
13455
13456   jresult = (void *)result;
13457   return jresult;
13458 }
13459
13460
13461 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) {
13462   void * jresult ;
13463   float arg1 ;
13464   float arg2 ;
13465   float arg3 ;
13466   float arg4 ;
13467   float arg5 ;
13468   float arg6 ;
13469   float arg7 ;
13470   float arg8 ;
13471   float arg9 ;
13472   Dali::Matrix3 *result = 0 ;
13473
13474   arg1 = (float)jarg1;
13475   arg2 = (float)jarg2;
13476   arg3 = (float)jarg3;
13477   arg4 = (float)jarg4;
13478   arg5 = (float)jarg5;
13479   arg6 = (float)jarg6;
13480   arg7 = (float)jarg7;
13481   arg8 = (float)jarg8;
13482   arg9 = (float)jarg9;
13483   {
13484     try {
13485       result = (Dali::Matrix3 *)new Dali::Matrix3(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9);
13486     } catch (std::out_of_range& e) {
13487       {
13488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13489       };
13490     } catch (std::exception& e) {
13491       {
13492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13493       };
13494     } catch (Dali::DaliException e) {
13495       {
13496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13497       };
13498     } catch (...) {
13499       {
13500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13501       };
13502     }
13503   }
13504
13505   jresult = (void *)result;
13506   return jresult;
13507 }
13508
13509
13510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_0(void * jarg1, void * jarg2) {
13511   void * jresult ;
13512   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13513   Dali::Matrix3 *arg2 = 0 ;
13514   Dali::Matrix3 *result = 0 ;
13515
13516   arg1 = (Dali::Matrix3 *)jarg1;
13517   arg2 = (Dali::Matrix3 *)jarg2;
13518   if (!arg2) {
13519     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13520     return 0;
13521   }
13522   {
13523     try {
13524       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix3 const &)*arg2);
13525     } catch (std::out_of_range& e) {
13526       {
13527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13528       };
13529     } catch (std::exception& e) {
13530       {
13531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13532       };
13533     } catch (Dali::DaliException e) {
13534       {
13535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13536       };
13537     } catch (...) {
13538       {
13539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13540       };
13541     }
13542   }
13543
13544   jresult = (void *)result;
13545   return jresult;
13546 }
13547
13548
13549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_Assign__SWIG_1(void * jarg1, void * jarg2) {
13550   void * jresult ;
13551   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13552   Dali::Matrix *arg2 = 0 ;
13553   Dali::Matrix3 *result = 0 ;
13554
13555   arg1 = (Dali::Matrix3 *)jarg1;
13556   arg2 = (Dali::Matrix *)jarg2;
13557   if (!arg2) {
13558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
13559     return 0;
13560   }
13561   {
13562     try {
13563       result = (Dali::Matrix3 *) &(arg1)->operator =((Dali::Matrix const &)*arg2);
13564     } catch (std::out_of_range& e) {
13565       {
13566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13567       };
13568     } catch (std::exception& e) {
13569       {
13570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13571       };
13572     } catch (Dali::DaliException e) {
13573       {
13574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13575       };
13576     } catch (...) {
13577       {
13578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13579       };
13580     }
13581   }
13582
13583   jresult = (void *)result;
13584   return jresult;
13585 }
13586
13587
13588 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_EqualTo(void * jarg1, void * jarg2) {
13589   unsigned int jresult ;
13590   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13591   Dali::Matrix3 *arg2 = 0 ;
13592   bool result;
13593
13594   arg1 = (Dali::Matrix3 *)jarg1;
13595   arg2 = (Dali::Matrix3 *)jarg2;
13596   if (!arg2) {
13597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13598     return 0;
13599   }
13600   {
13601     try {
13602       result = (bool)((Dali::Matrix3 const *)arg1)->operator ==((Dali::Matrix3 const &)*arg2);
13603     } catch (std::out_of_range& e) {
13604       {
13605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13606       };
13607     } catch (std::exception& e) {
13608       {
13609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13610       };
13611     } catch (Dali::DaliException e) {
13612       {
13613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13614       };
13615     } catch (...) {
13616       {
13617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13618       };
13619     }
13620   }
13621
13622   jresult = result;
13623   return jresult;
13624 }
13625
13626
13627 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_NotEqualTo(void * jarg1, void * jarg2) {
13628   unsigned int jresult ;
13629   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13630   Dali::Matrix3 *arg2 = 0 ;
13631   bool result;
13632
13633   arg1 = (Dali::Matrix3 *)jarg1;
13634   arg2 = (Dali::Matrix3 *)jarg2;
13635   if (!arg2) {
13636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13637     return 0;
13638   }
13639   {
13640     try {
13641       result = (bool)((Dali::Matrix3 const *)arg1)->operator !=((Dali::Matrix3 const &)*arg2);
13642     } catch (std::out_of_range& e) {
13643       {
13644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13645       };
13646     } catch (std::exception& e) {
13647       {
13648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13649       };
13650     } catch (Dali::DaliException e) {
13651       {
13652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13653       };
13654     } catch (...) {
13655       {
13656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13657       };
13658     }
13659   }
13660
13661   jresult = result;
13662   return jresult;
13663 }
13664
13665
13666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Matrix3(void * jarg1) {
13667   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13668
13669   arg1 = (Dali::Matrix3 *)jarg1;
13670   {
13671     try {
13672       delete arg1;
13673     } catch (std::out_of_range& e) {
13674       {
13675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13676       };
13677     } catch (std::exception& e) {
13678       {
13679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13680       };
13681     } catch (Dali::DaliException e) {
13682       {
13683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13684       };
13685     } catch (...) {
13686       {
13687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13688       };
13689     }
13690   }
13691
13692 }
13693
13694
13695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_SetIdentity(void * jarg1) {
13696   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13697
13698   arg1 = (Dali::Matrix3 *)jarg1;
13699   {
13700     try {
13701       (arg1)->SetIdentity();
13702     } catch (std::out_of_range& e) {
13703       {
13704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13705       };
13706     } catch (std::exception& e) {
13707       {
13708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13709       };
13710     } catch (Dali::DaliException e) {
13711       {
13712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13713       };
13714     } catch (...) {
13715       {
13716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13717       };
13718     }
13719   }
13720
13721 }
13722
13723
13724 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Matrix3_AsFloat__SWIG_0(void * jarg1) {
13725   void * jresult ;
13726   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13727   float *result = 0 ;
13728
13729   arg1 = (Dali::Matrix3 *)jarg1;
13730   {
13731     try {
13732       result = (float *)((Dali::Matrix3 const *)arg1)->AsFloat();
13733     } catch (std::out_of_range& e) {
13734       {
13735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13736       };
13737     } catch (std::exception& e) {
13738       {
13739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13740       };
13741     } catch (Dali::DaliException e) {
13742       {
13743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13744       };
13745     } catch (...) {
13746       {
13747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13748       };
13749     }
13750   }
13751
13752   jresult = (void *)result;
13753   return jresult;
13754 }
13755
13756
13757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Invert(void * jarg1) {
13758   unsigned int jresult ;
13759   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13760   bool result;
13761
13762   arg1 = (Dali::Matrix3 *)jarg1;
13763   {
13764     try {
13765       result = (bool)(arg1)->Invert();
13766     } catch (std::out_of_range& e) {
13767       {
13768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13769       };
13770     } catch (std::exception& e) {
13771       {
13772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13773       };
13774     } catch (Dali::DaliException e) {
13775       {
13776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13777       };
13778     } catch (...) {
13779       {
13780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13781       };
13782     }
13783   }
13784
13785   jresult = result;
13786   return jresult;
13787 }
13788
13789
13790 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_Transpose(void * jarg1) {
13791   unsigned int jresult ;
13792   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13793   bool result;
13794
13795   arg1 = (Dali::Matrix3 *)jarg1;
13796   {
13797     try {
13798       result = (bool)(arg1)->Transpose();
13799     } catch (std::out_of_range& e) {
13800       {
13801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13802       };
13803     } catch (std::exception& e) {
13804       {
13805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13806       };
13807     } catch (Dali::DaliException e) {
13808       {
13809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13810       };
13811     } catch (...) {
13812       {
13813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13814       };
13815     }
13816   }
13817
13818   jresult = result;
13819   return jresult;
13820 }
13821
13822
13823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Scale(void * jarg1, float jarg2) {
13824   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13825   float arg2 ;
13826
13827   arg1 = (Dali::Matrix3 *)jarg1;
13828   arg2 = (float)jarg2;
13829   {
13830     try {
13831       (arg1)->Scale(arg2);
13832     } catch (std::out_of_range& e) {
13833       {
13834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13835       };
13836     } catch (std::exception& e) {
13837       {
13838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13839       };
13840     } catch (Dali::DaliException e) {
13841       {
13842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13843       };
13844     } catch (...) {
13845       {
13846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13847       };
13848     }
13849   }
13850
13851 }
13852
13853
13854 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Matrix3_Magnitude(void * jarg1) {
13855   float jresult ;
13856   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13857   float result;
13858
13859   arg1 = (Dali::Matrix3 *)jarg1;
13860   {
13861     try {
13862       result = (float)((Dali::Matrix3 const *)arg1)->Magnitude();
13863     } catch (std::out_of_range& e) {
13864       {
13865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13866       };
13867     } catch (std::exception& e) {
13868       {
13869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13870       };
13871     } catch (Dali::DaliException e) {
13872       {
13873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13874       };
13875     } catch (...) {
13876       {
13877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13878       };
13879     }
13880   }
13881
13882   jresult = result;
13883   return jresult;
13884 }
13885
13886
13887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Matrix3_ScaledInverseTranspose(void * jarg1) {
13888   unsigned int jresult ;
13889   Dali::Matrix3 *arg1 = (Dali::Matrix3 *) 0 ;
13890   bool result;
13891
13892   arg1 = (Dali::Matrix3 *)jarg1;
13893   {
13894     try {
13895       result = (bool)(arg1)->ScaledInverseTranspose();
13896     } catch (std::out_of_range& e) {
13897       {
13898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13899       };
13900     } catch (std::exception& e) {
13901       {
13902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13903       };
13904     } catch (Dali::DaliException e) {
13905       {
13906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13907       };
13908     } catch (...) {
13909       {
13910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13911       };
13912     }
13913   }
13914
13915   jresult = result;
13916   return jresult;
13917 }
13918
13919
13920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Matrix3_Multiply(void * jarg1, void * jarg2, void * jarg3) {
13921   Dali::Matrix3 *arg1 = 0 ;
13922   Dali::Matrix3 *arg2 = 0 ;
13923   Dali::Matrix3 *arg3 = 0 ;
13924
13925   arg1 = (Dali::Matrix3 *)jarg1;
13926   if (!arg1) {
13927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
13928     return ;
13929   }
13930   arg2 = (Dali::Matrix3 *)jarg2;
13931   if (!arg2) {
13932     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13933     return ;
13934   }
13935   arg3 = (Dali::Matrix3 *)jarg3;
13936   if (!arg3) {
13937     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
13938     return ;
13939   }
13940   {
13941     try {
13942       Dali::Matrix3::Multiply(*arg1,(Dali::Matrix3 const &)*arg2,(Dali::Matrix3 const &)*arg3);
13943     } catch (std::out_of_range& e) {
13944       {
13945         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
13946       };
13947     } catch (std::exception& e) {
13948       {
13949         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
13950       };
13951     } catch (Dali::DaliException e) {
13952       {
13953         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
13954       };
13955     } catch (...) {
13956       {
13957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
13958       };
13959     }
13960   }
13961
13962 }
13963
13964
13965 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Range(float jarg1, float jarg2) {
13966   float jresult ;
13967   float arg1 ;
13968   float arg2 ;
13969   float result;
13970
13971   arg1 = (float)jarg1;
13972   arg2 = (float)jarg2;
13973   {
13974     try {
13975       result = (float)Dali::Random::Range(arg1,arg2);
13976     } catch (std::out_of_range& e) {
13977       {
13978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
13979       };
13980     } catch (std::exception& e) {
13981       {
13982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
13983       };
13984     } catch (Dali::DaliException e) {
13985       {
13986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
13987       };
13988     } catch (...) {
13989       {
13990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
13991       };
13992     }
13993   }
13994
13995   jresult = result;
13996   return jresult;
13997 }
13998
13999
14000 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Axis() {
14001   void * jresult ;
14002   Dali::Vector4 result;
14003
14004   {
14005     try {
14006       result = Dali::Random::Axis();
14007     } catch (std::out_of_range& e) {
14008       {
14009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14010       };
14011     } catch (std::exception& e) {
14012       {
14013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14014       };
14015     } catch (Dali::DaliException e) {
14016       {
14017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14018       };
14019     } catch (...) {
14020       {
14021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14022       };
14023     }
14024   }
14025
14026   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
14027   return jresult;
14028 }
14029
14030
14031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_0() {
14032   void * jresult ;
14033   Dali::AngleAxis *result = 0 ;
14034
14035   {
14036     try {
14037       result = (Dali::AngleAxis *)new Dali::AngleAxis();
14038     } catch (std::out_of_range& e) {
14039       {
14040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14041       };
14042     } catch (std::exception& e) {
14043       {
14044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14045       };
14046     } catch (Dali::DaliException e) {
14047       {
14048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14049       };
14050     } catch (...) {
14051       {
14052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14053       };
14054     }
14055   }
14056
14057   jresult = (void *)result;
14058   return jresult;
14059 }
14060
14061
14062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleAxis__SWIG_1(void * jarg1, void * jarg2) {
14063   void * jresult ;
14064   Dali::Radian arg1 ;
14065   Dali::Vector3 *arg2 = 0 ;
14066   Dali::Radian *argp1 ;
14067   Dali::AngleAxis *result = 0 ;
14068
14069   argp1 = (Dali::Radian *)jarg1;
14070   if (!argp1) {
14071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
14072     return 0;
14073   }
14074   arg1 = *argp1;
14075   arg2 = (Dali::Vector3 *)jarg2;
14076   if (!arg2) {
14077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
14078     return 0;
14079   }
14080   {
14081     try {
14082       result = (Dali::AngleAxis *)new Dali::AngleAxis(arg1,(Dali::Vector3 const &)*arg2);
14083     } catch (std::out_of_range& e) {
14084       {
14085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14086       };
14087     } catch (std::exception& e) {
14088       {
14089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14090       };
14091     } catch (Dali::DaliException e) {
14092       {
14093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14094       };
14095     } catch (...) {
14096       {
14097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14098       };
14099     }
14100   }
14101
14102   jresult = (void *)result;
14103   return jresult;
14104 }
14105
14106
14107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_angle_set(void * jarg1, void * jarg2) {
14108   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14109   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
14110
14111   arg1 = (Dali::AngleAxis *)jarg1;
14112   arg2 = (Dali::Radian *)jarg2;
14113   if (arg1) (arg1)->angle = *arg2;
14114 }
14115
14116
14117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_angle_get(void * jarg1) {
14118   void * jresult ;
14119   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14120   Dali::Radian *result = 0 ;
14121
14122   arg1 = (Dali::AngleAxis *)jarg1;
14123   result = (Dali::Radian *)& ((arg1)->angle);
14124   jresult = (void *)result;
14125   return jresult;
14126 }
14127
14128
14129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleAxis_axis_set(void * jarg1, void * jarg2) {
14130   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14131   Dali::Vector3 *arg2 = (Dali::Vector3 *) 0 ;
14132
14133   arg1 = (Dali::AngleAxis *)jarg1;
14134   arg2 = (Dali::Vector3 *)jarg2;
14135   if (arg1) (arg1)->axis = *arg2;
14136 }
14137
14138
14139 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleAxis_axis_get(void * jarg1) {
14140   void * jresult ;
14141   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14142   Dali::Vector3 *result = 0 ;
14143
14144   arg1 = (Dali::AngleAxis *)jarg1;
14145   result = (Dali::Vector3 *)& ((arg1)->axis);
14146   jresult = (void *)result;
14147   return jresult;
14148 }
14149
14150
14151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleAxis(void * jarg1) {
14152   Dali::AngleAxis *arg1 = (Dali::AngleAxis *) 0 ;
14153
14154   arg1 = (Dali::AngleAxis *)jarg1;
14155   {
14156     try {
14157       delete arg1;
14158     } catch (std::out_of_range& e) {
14159       {
14160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14161       };
14162     } catch (std::exception& e) {
14163       {
14164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14165       };
14166     } catch (Dali::DaliException e) {
14167       {
14168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14169       };
14170     } catch (...) {
14171       {
14172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14173       };
14174     }
14175   }
14176
14177 }
14178
14179
14180 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualTo__SWIG_9(void * jarg1, void * jarg2) {
14181   unsigned int jresult ;
14182   Dali::AngleAxis *arg1 = 0 ;
14183   Dali::AngleAxis *arg2 = 0 ;
14184   bool result;
14185
14186   arg1 = (Dali::AngleAxis *)jarg1;
14187   if (!arg1) {
14188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14189     return 0;
14190   }
14191   arg2 = (Dali::AngleAxis *)jarg2;
14192   if (!arg2) {
14193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
14194     return 0;
14195   }
14196   {
14197     try {
14198       result = (bool)Dali::operator ==((Dali::AngleAxis const &)*arg1,(Dali::AngleAxis const &)*arg2);
14199     } catch (std::out_of_range& e) {
14200       {
14201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14202       };
14203     } catch (std::exception& e) {
14204       {
14205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14206       };
14207     } catch (Dali::DaliException e) {
14208       {
14209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14210       };
14211     } catch (...) {
14212       {
14213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14214       };
14215     }
14216   }
14217
14218   jresult = result;
14219   return jresult;
14220 }
14221
14222
14223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NextPowerOfTwo(unsigned int jarg1) {
14224   unsigned int jresult ;
14225   unsigned int arg1 ;
14226   unsigned int result;
14227
14228   arg1 = (unsigned int)jarg1;
14229   {
14230     try {
14231       result = (unsigned int)Dali::NextPowerOfTwo(arg1);
14232     } catch (std::out_of_range& e) {
14233       {
14234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14235       };
14236     } catch (std::exception& e) {
14237       {
14238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14239       };
14240     } catch (Dali::DaliException e) {
14241       {
14242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14243       };
14244     } catch (...) {
14245       {
14246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14247       };
14248     }
14249   }
14250
14251   jresult = result;
14252   return jresult;
14253 }
14254
14255
14256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsPowerOfTwo(unsigned int jarg1) {
14257   unsigned int jresult ;
14258   unsigned int arg1 ;
14259   bool result;
14260
14261   arg1 = (unsigned int)jarg1;
14262   {
14263     try {
14264       result = (bool)Dali::IsPowerOfTwo(arg1);
14265     } catch (std::out_of_range& e) {
14266       {
14267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14268       };
14269     } catch (std::exception& e) {
14270       {
14271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14272       };
14273     } catch (Dali::DaliException e) {
14274       {
14275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14276       };
14277     } catch (...) {
14278       {
14279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14280       };
14281     }
14282   }
14283
14284   jresult = result;
14285   return jresult;
14286 }
14287
14288
14289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_GetRangedEpsilon(float jarg1, float jarg2) {
14290   float jresult ;
14291   float arg1 ;
14292   float arg2 ;
14293   float result;
14294
14295   arg1 = (float)jarg1;
14296   arg2 = (float)jarg2;
14297   {
14298     try {
14299       result = (float)Dali::GetRangedEpsilon(arg1,arg2);
14300     } catch (std::out_of_range& e) {
14301       {
14302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14303       };
14304     } catch (std::exception& e) {
14305       {
14306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14307       };
14308     } catch (Dali::DaliException e) {
14309       {
14310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14311       };
14312     } catch (...) {
14313       {
14314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14315       };
14316     }
14317   }
14318
14319   jresult = result;
14320   return jresult;
14321 }
14322
14323
14324 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_EqualsZero(float jarg1) {
14325   unsigned int jresult ;
14326   float arg1 ;
14327   bool result;
14328
14329   arg1 = (float)jarg1;
14330   {
14331     try {
14332       result = (bool)Dali::EqualsZero(arg1);
14333     } catch (std::out_of_range& e) {
14334       {
14335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14336       };
14337     } catch (std::exception& e) {
14338       {
14339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14340       };
14341     } catch (Dali::DaliException e) {
14342       {
14343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14344       };
14345     } catch (...) {
14346       {
14347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14348       };
14349     }
14350   }
14351
14352   jresult = result;
14353   return jresult;
14354 }
14355
14356
14357 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_0(float jarg1, float jarg2) {
14358   unsigned int jresult ;
14359   float arg1 ;
14360   float arg2 ;
14361   bool result;
14362
14363   arg1 = (float)jarg1;
14364   arg2 = (float)jarg2;
14365   {
14366     try {
14367       result = (bool)Dali::Equals(arg1,arg2);
14368     } catch (std::out_of_range& e) {
14369       {
14370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14371       };
14372     } catch (std::exception& e) {
14373       {
14374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14375       };
14376     } catch (Dali::DaliException e) {
14377       {
14378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14379       };
14380     } catch (...) {
14381       {
14382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14383       };
14384     }
14385   }
14386
14387   jresult = result;
14388   return jresult;
14389 }
14390
14391
14392 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Equals__SWIG_1(float jarg1, float jarg2, float jarg3) {
14393   unsigned int jresult ;
14394   float arg1 ;
14395   float arg2 ;
14396   float arg3 ;
14397   bool result;
14398
14399   arg1 = (float)jarg1;
14400   arg2 = (float)jarg2;
14401   arg3 = (float)jarg3;
14402   {
14403     try {
14404       result = (bool)Dali::Equals(arg1,arg2,arg3);
14405     } catch (std::out_of_range& e) {
14406       {
14407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14408       };
14409     } catch (std::exception& e) {
14410       {
14411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14412       };
14413     } catch (Dali::DaliException e) {
14414       {
14415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14416       };
14417     } catch (...) {
14418       {
14419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14420       };
14421     }
14422   }
14423
14424   jresult = result;
14425   return jresult;
14426 }
14427
14428
14429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Round(float jarg1, int jarg2) {
14430   float jresult ;
14431   float arg1 ;
14432   int arg2 ;
14433   float result;
14434
14435   arg1 = (float)jarg1;
14436   arg2 = (int)jarg2;
14437   {
14438     try {
14439       result = (float)Dali::Round(arg1,arg2);
14440     } catch (std::out_of_range& e) {
14441       {
14442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14443       };
14444     } catch (std::exception& e) {
14445       {
14446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14447       };
14448     } catch (Dali::DaliException e) {
14449       {
14450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14451       };
14452     } catch (...) {
14453       {
14454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14455       };
14456     }
14457   }
14458
14459   jresult = result;
14460   return jresult;
14461 }
14462
14463
14464 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_WrapInDomain(float jarg1, float jarg2, float jarg3) {
14465   float jresult ;
14466   float arg1 ;
14467   float arg2 ;
14468   float arg3 ;
14469   float result;
14470
14471   arg1 = (float)jarg1;
14472   arg2 = (float)jarg2;
14473   arg3 = (float)jarg3;
14474   {
14475     try {
14476       result = (float)Dali::WrapInDomain(arg1,arg2,arg3);
14477     } catch (std::out_of_range& e) {
14478       {
14479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14480       };
14481     } catch (std::exception& e) {
14482       {
14483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14484       };
14485     } catch (Dali::DaliException e) {
14486       {
14487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14488       };
14489     } catch (...) {
14490       {
14491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14492       };
14493     }
14494   }
14495
14496   jresult = result;
14497   return jresult;
14498 }
14499
14500
14501 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ShortestDistanceInDomain(float jarg1, float jarg2, float jarg3, float jarg4) {
14502   float jresult ;
14503   float arg1 ;
14504   float arg2 ;
14505   float arg3 ;
14506   float arg4 ;
14507   float result;
14508
14509   arg1 = (float)jarg1;
14510   arg2 = (float)jarg2;
14511   arg3 = (float)jarg3;
14512   arg4 = (float)jarg4;
14513   {
14514     try {
14515       result = (float)Dali::ShortestDistanceInDomain(arg1,arg2,arg3,arg4);
14516     } catch (std::out_of_range& e) {
14517       {
14518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14519       };
14520     } catch (std::exception& e) {
14521       {
14522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14523       };
14524     } catch (Dali::DaliException e) {
14525       {
14526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14527       };
14528     } catch (...) {
14529       {
14530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14531       };
14532     }
14533   }
14534
14535   jresult = result;
14536   return jresult;
14537 }
14538
14539
14540 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_INDEX_get() {
14541   int jresult ;
14542   int result;
14543
14544   result = (int)(int)Dali::Property::INVALID_INDEX;
14545   jresult = result;
14546   return jresult;
14547 }
14548
14549
14550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_KEY_get() {
14551   int jresult ;
14552   int result;
14553
14554   result = (int)(int)Dali::Property::INVALID_KEY;
14555   jresult = result;
14556   return jresult;
14557 }
14558
14559
14560 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_INVALID_COMPONENT_INDEX_get() {
14561   int jresult ;
14562   int result;
14563
14564   result = (int)(int)Dali::Property::INVALID_COMPONENT_INDEX;
14565   jresult = result;
14566   return jresult;
14567 }
14568
14569
14570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_0(void * jarg1, int jarg2) {
14571   void * jresult ;
14572   Dali::Handle *arg1 = 0 ;
14573   Dali::Property::Index arg2 ;
14574   Dali::Property *result = 0 ;
14575
14576   arg1 = (Dali::Handle *)jarg1;
14577   if (!arg1) {
14578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14579     return 0;
14580   }
14581   arg2 = (Dali::Property::Index)jarg2;
14582   {
14583     try {
14584       result = (Dali::Property *)new Dali::Property(*arg1,arg2);
14585     } catch (std::out_of_range& e) {
14586       {
14587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14588       };
14589     } catch (std::exception& e) {
14590       {
14591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14592       };
14593     } catch (Dali::DaliException e) {
14594       {
14595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14596       };
14597     } catch (...) {
14598       {
14599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14600       };
14601     }
14602   }
14603
14604   jresult = (void *)result;
14605   return jresult;
14606 }
14607
14608
14609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_1(void * jarg1, int jarg2, int jarg3) {
14610   void * jresult ;
14611   Dali::Handle *arg1 = 0 ;
14612   Dali::Property::Index arg2 ;
14613   int arg3 ;
14614   Dali::Property *result = 0 ;
14615
14616   arg1 = (Dali::Handle *)jarg1;
14617   if (!arg1) {
14618     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14619     return 0;
14620   }
14621   arg2 = (Dali::Property::Index)jarg2;
14622   arg3 = (int)jarg3;
14623   {
14624     try {
14625       result = (Dali::Property *)new Dali::Property(*arg1,arg2,arg3);
14626     } catch (std::out_of_range& e) {
14627       {
14628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14629       };
14630     } catch (std::exception& e) {
14631       {
14632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14633       };
14634     } catch (Dali::DaliException e) {
14635       {
14636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14637       };
14638     } catch (...) {
14639       {
14640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14641       };
14642     }
14643   }
14644
14645   jresult = (void *)result;
14646   return jresult;
14647 }
14648
14649
14650 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_2(void * jarg1, char * jarg2) {
14651   void * jresult ;
14652   Dali::Handle *arg1 = 0 ;
14653   std::string *arg2 = 0 ;
14654   Dali::Property *result = 0 ;
14655
14656   arg1 = (Dali::Handle *)jarg1;
14657   if (!arg1) {
14658     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14659     return 0;
14660   }
14661   if (!jarg2) {
14662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14663     return 0;
14664   }
14665   std::string arg2_str(jarg2);
14666   arg2 = &arg2_str;
14667   {
14668     try {
14669       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2);
14670     } catch (std::out_of_range& e) {
14671       {
14672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14673       };
14674     } catch (std::exception& e) {
14675       {
14676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14677       };
14678     } catch (Dali::DaliException e) {
14679       {
14680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14681       };
14682     } catch (...) {
14683       {
14684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14685       };
14686     }
14687   }
14688
14689   jresult = (void *)result;
14690
14691   //argout typemap for const std::string&
14692
14693   return jresult;
14694 }
14695
14696
14697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property__SWIG_3(void * jarg1, char * jarg2, int jarg3) {
14698   void * jresult ;
14699   Dali::Handle *arg1 = 0 ;
14700   std::string *arg2 = 0 ;
14701   int arg3 ;
14702   Dali::Property *result = 0 ;
14703
14704   arg1 = (Dali::Handle *)jarg1;
14705   if (!arg1) {
14706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14707     return 0;
14708   }
14709   if (!jarg2) {
14710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
14711     return 0;
14712   }
14713   std::string arg2_str(jarg2);
14714   arg2 = &arg2_str;
14715   arg3 = (int)jarg3;
14716   {
14717     try {
14718       result = (Dali::Property *)new Dali::Property(*arg1,(std::string const &)*arg2,arg3);
14719     } catch (std::out_of_range& e) {
14720       {
14721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14722       };
14723     } catch (std::exception& e) {
14724       {
14725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14726       };
14727     } catch (Dali::DaliException e) {
14728       {
14729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14730       };
14731     } catch (...) {
14732       {
14733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14734       };
14735     }
14736   }
14737
14738   jresult = (void *)result;
14739
14740   //argout typemap for const std::string&
14741
14742   return jresult;
14743 }
14744
14745
14746 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property(void * jarg1) {
14747   Dali::Property *arg1 = (Dali::Property *) 0 ;
14748
14749   arg1 = (Dali::Property *)jarg1;
14750   {
14751     try {
14752       delete arg1;
14753     } catch (std::out_of_range& e) {
14754       {
14755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14756       };
14757     } catch (std::exception& e) {
14758       {
14759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14760       };
14761     } catch (Dali::DaliException e) {
14762       {
14763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14764       };
14765     } catch (...) {
14766       {
14767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14768       };
14769     }
14770   }
14771
14772 }
14773
14774
14775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property__object_set(void * jarg1, void * jarg2) {
14776   Dali::Property *arg1 = (Dali::Property *) 0 ;
14777   Dali::Handle *arg2 = 0 ;
14778
14779   arg1 = (Dali::Property *)jarg1;
14780   arg2 = (Dali::Handle *)jarg2;
14781   if (!arg2) {
14782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
14783     return ;
14784   }
14785   if (arg1) (arg1)->object = *arg2;
14786 }
14787
14788
14789 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property__object_get(void * jarg1) {
14790   void * jresult ;
14791   Dali::Property *arg1 = (Dali::Property *) 0 ;
14792   Dali::Handle *result = 0 ;
14793
14794   arg1 = (Dali::Property *)jarg1;
14795   result = (Dali::Handle *) &(Dali::Handle &) ((arg1)->object);
14796   jresult = (void *)result;
14797   return jresult;
14798 }
14799
14800
14801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_propertyIndex_set(void * jarg1, int jarg2) {
14802   Dali::Property *arg1 = (Dali::Property *) 0 ;
14803   Dali::Property::Index arg2 ;
14804
14805   arg1 = (Dali::Property *)jarg1;
14806   arg2 = (Dali::Property::Index)jarg2;
14807   if (arg1) (arg1)->propertyIndex = arg2;
14808 }
14809
14810
14811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_propertyIndex_get(void * jarg1) {
14812   int jresult ;
14813   Dali::Property *arg1 = (Dali::Property *) 0 ;
14814   Dali::Property::Index result;
14815
14816   arg1 = (Dali::Property *)jarg1;
14817   result = (Dali::Property::Index) ((arg1)->propertyIndex);
14818   jresult = result;
14819   return jresult;
14820 }
14821
14822
14823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_componentIndex_set(void * jarg1, int jarg2) {
14824   Dali::Property *arg1 = (Dali::Property *) 0 ;
14825   int arg2 ;
14826
14827   arg1 = (Dali::Property *)jarg1;
14828   arg2 = (int)jarg2;
14829   if (arg1) (arg1)->componentIndex = arg2;
14830 }
14831
14832
14833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_componentIndex_get(void * jarg1) {
14834   int jresult ;
14835   Dali::Property *arg1 = (Dali::Property *) 0 ;
14836   int result;
14837
14838   arg1 = (Dali::Property *)jarg1;
14839   result = (int) ((arg1)->componentIndex);
14840   jresult = result;
14841   return jresult;
14842 }
14843
14844
14845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_0() {
14846   void * jresult ;
14847   Dali::Property::Array *result = 0 ;
14848
14849   {
14850     try {
14851       result = (Dali::Property::Array *)new Dali::Property::Array();
14852     } catch (std::out_of_range& e) {
14853       {
14854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14855       };
14856     } catch (std::exception& e) {
14857       {
14858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14859       };
14860     } catch (Dali::DaliException e) {
14861       {
14862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14863       };
14864     } catch (...) {
14865       {
14866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14867       };
14868     }
14869   }
14870
14871   jresult = (void *)result;
14872   return jresult;
14873 }
14874
14875
14876 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Array__SWIG_1(void * jarg1) {
14877   void * jresult ;
14878   Dali::Property::Array *arg1 = 0 ;
14879   Dali::Property::Array *result = 0 ;
14880
14881   arg1 = (Dali::Property::Array *)jarg1;
14882   if (!arg1) {
14883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
14884     return 0;
14885   }
14886   {
14887     try {
14888       result = (Dali::Property::Array *)new Dali::Property::Array((Dali::Property::Array const &)*arg1);
14889     } catch (std::out_of_range& e) {
14890       {
14891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14892       };
14893     } catch (std::exception& e) {
14894       {
14895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14896       };
14897     } catch (Dali::DaliException e) {
14898       {
14899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14900       };
14901     } catch (...) {
14902       {
14903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14904       };
14905     }
14906   }
14907
14908   jresult = (void *)result;
14909   return jresult;
14910 }
14911
14912
14913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Array(void * jarg1) {
14914   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14915
14916   arg1 = (Dali::Property::Array *)jarg1;
14917   {
14918     try {
14919       delete arg1;
14920     } catch (std::out_of_range& e) {
14921       {
14922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
14923       };
14924     } catch (std::exception& e) {
14925       {
14926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
14927       };
14928     } catch (Dali::DaliException e) {
14929       {
14930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
14931       };
14932     } catch (...) {
14933       {
14934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
14935       };
14936     }
14937   }
14938
14939 }
14940
14941
14942 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Size(void * jarg1) {
14943   unsigned long jresult ;
14944   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14945   Dali::Property::Array::SizeType result;
14946
14947   arg1 = (Dali::Property::Array *)jarg1;
14948   {
14949     try {
14950       result = ((Dali::Property::Array const *)arg1)->Size();
14951     } catch (std::out_of_range& e) {
14952       {
14953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14954       };
14955     } catch (std::exception& e) {
14956       {
14957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14958       };
14959     } catch (Dali::DaliException e) {
14960       {
14961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14962       };
14963     } catch (...) {
14964       {
14965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14966       };
14967     }
14968   }
14969
14970   jresult = (unsigned long)result;
14971   return jresult;
14972 }
14973
14974
14975 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Count(void * jarg1) {
14976   unsigned long jresult ;
14977   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
14978   Dali::Property::Array::SizeType result;
14979
14980   arg1 = (Dali::Property::Array *)jarg1;
14981   {
14982     try {
14983       result = ((Dali::Property::Array const *)arg1)->Count();
14984     } catch (std::out_of_range& e) {
14985       {
14986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
14987       };
14988     } catch (std::exception& e) {
14989       {
14990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
14991       };
14992     } catch (Dali::DaliException e) {
14993       {
14994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
14995       };
14996     } catch (...) {
14997       {
14998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
14999       };
15000     }
15001   }
15002
15003   jresult = (unsigned long)result;
15004   return jresult;
15005 }
15006
15007
15008 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Array_Empty(void * jarg1) {
15009   unsigned int jresult ;
15010   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15011   bool result;
15012
15013   arg1 = (Dali::Property::Array *)jarg1;
15014   {
15015     try {
15016       result = (bool)((Dali::Property::Array const *)arg1)->Empty();
15017     } catch (std::out_of_range& e) {
15018       {
15019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15020       };
15021     } catch (std::exception& e) {
15022       {
15023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15024       };
15025     } catch (Dali::DaliException e) {
15026       {
15027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15028       };
15029     } catch (...) {
15030       {
15031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15032       };
15033     }
15034   }
15035
15036   jresult = result;
15037   return jresult;
15038 }
15039
15040
15041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Clear(void * jarg1) {
15042   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15043
15044   arg1 = (Dali::Property::Array *)jarg1;
15045   {
15046     try {
15047       (arg1)->Clear();
15048     } catch (std::out_of_range& e) {
15049       {
15050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15051       };
15052     } catch (std::exception& e) {
15053       {
15054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15055       };
15056     } catch (Dali::DaliException e) {
15057       {
15058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15059       };
15060     } catch (...) {
15061       {
15062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15063       };
15064     }
15065   }
15066
15067 }
15068
15069
15070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Reserve(void * jarg1, unsigned long jarg2) {
15071   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15072   Dali::Property::Array::SizeType arg2 ;
15073
15074   arg1 = (Dali::Property::Array *)jarg1;
15075   arg2 = (Dali::Property::Array::SizeType)jarg2;
15076   {
15077     try {
15078       (arg1)->Reserve(arg2);
15079     } catch (std::out_of_range& e) {
15080       {
15081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15082       };
15083     } catch (std::exception& e) {
15084       {
15085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15086       };
15087     } catch (Dali::DaliException e) {
15088       {
15089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15090       };
15091     } catch (...) {
15092       {
15093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15094       };
15095     }
15096   }
15097
15098 }
15099
15100
15101 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_Resize(void * jarg1, unsigned long jarg2) {
15102   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15103   Dali::Property::Array::SizeType arg2 ;
15104
15105   arg1 = (Dali::Property::Array *)jarg1;
15106   arg2 = (Dali::Property::Array::SizeType)jarg2;
15107   {
15108     try {
15109       (arg1)->Resize(arg2);
15110     } catch (std::out_of_range& e) {
15111       {
15112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15113       };
15114     } catch (std::exception& e) {
15115       {
15116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15117       };
15118     } catch (Dali::DaliException e) {
15119       {
15120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15121       };
15122     } catch (...) {
15123       {
15124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15125       };
15126     }
15127   }
15128
15129 }
15130
15131
15132 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Array_Capacity(void * jarg1) {
15133   unsigned long jresult ;
15134   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15135   Dali::Property::Array::SizeType result;
15136
15137   arg1 = (Dali::Property::Array *)jarg1;
15138   {
15139     try {
15140       result = (arg1)->Capacity();
15141     } catch (std::out_of_range& e) {
15142       {
15143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15144       };
15145     } catch (std::exception& e) {
15146       {
15147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15148       };
15149     } catch (Dali::DaliException e) {
15150       {
15151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15152       };
15153     } catch (...) {
15154       {
15155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15156       };
15157     }
15158   }
15159
15160   jresult = (unsigned long)result;
15161   return jresult;
15162 }
15163
15164
15165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Array_PushBack(void * jarg1, void * jarg2) {
15166   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15167   Dali::Property::Value *arg2 = 0 ;
15168
15169   arg1 = (Dali::Property::Array *)jarg1;
15170   arg2 = (Dali::Property::Value *)jarg2;
15171   if (!arg2) {
15172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15173     return ;
15174   }
15175   {
15176     try {
15177       (arg1)->PushBack((Dali::Property::Value const &)*arg2);
15178     } catch (std::out_of_range& e) {
15179       {
15180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15181       };
15182     } catch (std::exception& e) {
15183       {
15184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15185       };
15186     } catch (Dali::DaliException e) {
15187       {
15188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15189       };
15190     } catch (...) {
15191       {
15192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15193       };
15194     }
15195   }
15196
15197 }
15198
15199
15200 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Add(void * jarg1, void * jarg2) {
15201   void * jresult ;
15202   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15203   Dali::Property::Value *arg2 = 0 ;
15204   Dali::Property::Array *result = 0 ;
15205
15206   arg1 = (Dali::Property::Array *)jarg1;
15207   arg2 = (Dali::Property::Value *)jarg2;
15208   if (!arg2) {
15209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15210     return 0;
15211   }
15212   {
15213     try {
15214       result = (Dali::Property::Array *) &(arg1)->Add((Dali::Property::Value const &)*arg2);
15215     } catch (std::out_of_range& e) {
15216       {
15217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15218       };
15219     } catch (std::exception& e) {
15220       {
15221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15222       };
15223     } catch (Dali::DaliException e) {
15224       {
15225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15226       };
15227     } catch (...) {
15228       {
15229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15230       };
15231     }
15232   }
15233
15234   jresult = (void *)result;
15235   return jresult;
15236 }
15237
15238
15239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_GetElementAt__SWIG_0(void * jarg1, unsigned long jarg2) {
15240   void * jresult ;
15241   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15242   Dali::Property::Array::SizeType arg2 ;
15243   Dali::Property::Value *result = 0 ;
15244
15245   arg1 = (Dali::Property::Array *)jarg1;
15246   arg2 = (Dali::Property::Array::SizeType)jarg2;
15247   {
15248     try {
15249       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->GetElementAt(arg2);
15250     } catch (std::out_of_range& e) {
15251       {
15252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15253       };
15254     } catch (std::exception& e) {
15255       {
15256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15257       };
15258     } catch (Dali::DaliException e) {
15259       {
15260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15261       };
15262     } catch (...) {
15263       {
15264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15265       };
15266     }
15267   }
15268
15269   jresult = (void *)result;
15270   return jresult;
15271 }
15272
15273
15274 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
15275   void * jresult ;
15276   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15277   Dali::Property::Array::SizeType arg2 ;
15278   Dali::Property::Value *result = 0 ;
15279
15280   arg1 = (Dali::Property::Array *)jarg1;
15281   arg2 = (Dali::Property::Array::SizeType)jarg2;
15282   {
15283     try {
15284       result = (Dali::Property::Value *) &((Dali::Property::Array const *)arg1)->operator [](arg2);
15285     } catch (std::out_of_range& e) {
15286       {
15287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15288       };
15289     } catch (std::exception& e) {
15290       {
15291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15292       };
15293     } catch (Dali::DaliException e) {
15294       {
15295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15296       };
15297     } catch (...) {
15298       {
15299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15300       };
15301     }
15302   }
15303
15304   jresult = (void *)result;
15305   return jresult;
15306 }
15307
15308
15309 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Array_Assign(void * jarg1, void * jarg2) {
15310   void * jresult ;
15311   Dali::Property::Array *arg1 = (Dali::Property::Array *) 0 ;
15312   Dali::Property::Array *arg2 = 0 ;
15313   Dali::Property::Array *result = 0 ;
15314
15315   arg1 = (Dali::Property::Array *)jarg1;
15316   arg2 = (Dali::Property::Array *)jarg2;
15317   if (!arg2) {
15318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
15319     return 0;
15320   }
15321   {
15322     try {
15323       result = (Dali::Property::Array *) &(arg1)->operator =((Dali::Property::Array const &)*arg2);
15324     } catch (std::out_of_range& e) {
15325       {
15326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15327       };
15328     } catch (std::exception& e) {
15329       {
15330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15331       };
15332     } catch (Dali::DaliException e) {
15333       {
15334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15335       };
15336     } catch (...) {
15337       {
15338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15339       };
15340     }
15341   }
15342
15343   jresult = (void *)result;
15344   return jresult;
15345 }
15346
15347
15348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_type_set(void * jarg1, int jarg2) {
15349   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15350   enum Dali::Property::Key::Type arg2 ;
15351
15352   arg1 = (Dali::Property::Key *)jarg1;
15353   arg2 = (enum Dali::Property::Key::Type)jarg2;
15354   if (arg1) (arg1)->type = arg2;
15355 }
15356
15357
15358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_type_get(void * jarg1) {
15359   int jresult ;
15360   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15361   enum Dali::Property::Key::Type result;
15362
15363   arg1 = (Dali::Property::Key *)jarg1;
15364   result = (enum Dali::Property::Key::Type) ((arg1)->type);
15365   jresult = (int)result;
15366   return jresult;
15367 }
15368
15369
15370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_set(void * jarg1, int jarg2) {
15371   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15372   Dali::Property::Index arg2 ;
15373
15374   arg1 = (Dali::Property::Key *)jarg1;
15375   arg2 = (Dali::Property::Index)jarg2;
15376   if (arg1) (arg1)->indexKey = arg2;
15377 }
15378
15379
15380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Key_indexKey_get(void * jarg1) {
15381   int jresult ;
15382   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15383   Dali::Property::Index result;
15384
15385   arg1 = (Dali::Property::Key *)jarg1;
15386   result = (Dali::Property::Index) ((arg1)->indexKey);
15387   jresult = result;
15388   return jresult;
15389 }
15390
15391
15392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_set(void * jarg1, char * jarg2) {
15393   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15394   std::string *arg2 = 0 ;
15395
15396   arg1 = (Dali::Property::Key *)jarg1;
15397   if (!jarg2) {
15398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15399     return ;
15400   }
15401   std::string arg2_str(jarg2);
15402   arg2 = &arg2_str;
15403   if (arg1) (arg1)->stringKey = *arg2;
15404
15405   //argout typemap for const std::string&
15406
15407 }
15408
15409
15410 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Key_stringKey_get(void * jarg1) {
15411   char * jresult ;
15412   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15413   std::string *result = 0 ;
15414
15415   arg1 = (Dali::Property::Key *)jarg1;
15416   result = (std::string *) & ((arg1)->stringKey);
15417   jresult = SWIG_csharp_string_callback(result->c_str());
15418   return jresult;
15419 }
15420
15421
15422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_0(char * jarg1) {
15423   void * jresult ;
15424   std::string *arg1 = 0 ;
15425   Dali::Property::Key *result = 0 ;
15426
15427   if (!jarg1) {
15428     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15429     return 0;
15430   }
15431   std::string arg1_str(jarg1);
15432   arg1 = &arg1_str;
15433   {
15434     try {
15435       result = (Dali::Property::Key *)new Dali::Property::Key((std::string const &)*arg1);
15436     } catch (std::out_of_range& e) {
15437       {
15438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15439       };
15440     } catch (std::exception& e) {
15441       {
15442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15443       };
15444     } catch (Dali::DaliException e) {
15445       {
15446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15447       };
15448     } catch (...) {
15449       {
15450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15451       };
15452     }
15453   }
15454
15455   jresult = (void *)result;
15456
15457   //argout typemap for const std::string&
15458
15459   return jresult;
15460 }
15461
15462
15463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Key__SWIG_1(int jarg1) {
15464   void * jresult ;
15465   Dali::Property::Index arg1 ;
15466   Dali::Property::Key *result = 0 ;
15467
15468   arg1 = (Dali::Property::Index)jarg1;
15469   {
15470     try {
15471       result = (Dali::Property::Key *)new Dali::Property::Key(arg1);
15472     } catch (std::out_of_range& e) {
15473       {
15474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15475       };
15476     } catch (std::exception& e) {
15477       {
15478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15479       };
15480     } catch (Dali::DaliException e) {
15481       {
15482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15483       };
15484     } catch (...) {
15485       {
15486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15487       };
15488     }
15489   }
15490
15491   jresult = (void *)result;
15492   return jresult;
15493 }
15494
15495
15496 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_0(void * jarg1, char * jarg2) {
15497   unsigned int jresult ;
15498   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15499   std::string *arg2 = 0 ;
15500   bool result;
15501
15502   arg1 = (Dali::Property::Key *)jarg1;
15503   if (!jarg2) {
15504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15505     return 0;
15506   }
15507   std::string arg2_str(jarg2);
15508   arg2 = &arg2_str;
15509   {
15510     try {
15511       result = (bool)(arg1)->operator ==((std::string const &)*arg2);
15512     } catch (std::out_of_range& e) {
15513       {
15514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15515       };
15516     } catch (std::exception& e) {
15517       {
15518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15519       };
15520     } catch (Dali::DaliException e) {
15521       {
15522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15523       };
15524     } catch (...) {
15525       {
15526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15527       };
15528     }
15529   }
15530
15531   jresult = result;
15532
15533   //argout typemap for const std::string&
15534
15535   return jresult;
15536 }
15537
15538
15539 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_1(void * jarg1, int jarg2) {
15540   unsigned int jresult ;
15541   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15542   Dali::Property::Index arg2 ;
15543   bool result;
15544
15545   arg1 = (Dali::Property::Key *)jarg1;
15546   arg2 = (Dali::Property::Index)jarg2;
15547   {
15548     try {
15549       result = (bool)(arg1)->operator ==(arg2);
15550     } catch (std::out_of_range& e) {
15551       {
15552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15553       };
15554     } catch (std::exception& e) {
15555       {
15556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15557       };
15558     } catch (Dali::DaliException e) {
15559       {
15560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15561       };
15562     } catch (...) {
15563       {
15564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15565       };
15566     }
15567   }
15568
15569   jresult = result;
15570   return jresult;
15571 }
15572
15573
15574 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_EqualTo__SWIG_2(void * jarg1, void * jarg2) {
15575   unsigned int jresult ;
15576   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15577   Dali::Property::Key *arg2 = 0 ;
15578   bool result;
15579
15580   arg1 = (Dali::Property::Key *)jarg1;
15581   arg2 = (Dali::Property::Key *)jarg2;
15582   if (!arg2) {
15583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15584     return 0;
15585   }
15586   {
15587     try {
15588       result = (bool)(arg1)->operator ==((Dali::Property::Key const &)*arg2);
15589     } catch (std::out_of_range& e) {
15590       {
15591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15592       };
15593     } catch (std::exception& e) {
15594       {
15595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15596       };
15597     } catch (Dali::DaliException e) {
15598       {
15599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15600       };
15601     } catch (...) {
15602       {
15603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15604       };
15605     }
15606   }
15607
15608   jresult = result;
15609   return jresult;
15610 }
15611
15612
15613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_0(void * jarg1, char * jarg2) {
15614   unsigned int jresult ;
15615   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15616   std::string *arg2 = 0 ;
15617   bool result;
15618
15619   arg1 = (Dali::Property::Key *)jarg1;
15620   if (!jarg2) {
15621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
15622     return 0;
15623   }
15624   std::string arg2_str(jarg2);
15625   arg2 = &arg2_str;
15626   {
15627     try {
15628       result = (bool)(arg1)->operator !=((std::string const &)*arg2);
15629     } catch (std::out_of_range& e) {
15630       {
15631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15632       };
15633     } catch (std::exception& e) {
15634       {
15635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15636       };
15637     } catch (Dali::DaliException e) {
15638       {
15639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15640       };
15641     } catch (...) {
15642       {
15643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15644       };
15645     }
15646   }
15647
15648   jresult = result;
15649
15650   //argout typemap for const std::string&
15651
15652   return jresult;
15653 }
15654
15655
15656 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_1(void * jarg1, int jarg2) {
15657   unsigned int jresult ;
15658   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15659   Dali::Property::Index arg2 ;
15660   bool result;
15661
15662   arg1 = (Dali::Property::Key *)jarg1;
15663   arg2 = (Dali::Property::Index)jarg2;
15664   {
15665     try {
15666       result = (bool)(arg1)->operator !=(arg2);
15667     } catch (std::out_of_range& e) {
15668       {
15669         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15670       };
15671     } catch (std::exception& e) {
15672       {
15673         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15674       };
15675     } catch (Dali::DaliException e) {
15676       {
15677         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15678       };
15679     } catch (...) {
15680       {
15681         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15682       };
15683     }
15684   }
15685
15686   jresult = result;
15687   return jresult;
15688 }
15689
15690
15691 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Key_NotEqualTo__SWIG_2(void * jarg1, void * jarg2) {
15692   unsigned int jresult ;
15693   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15694   Dali::Property::Key *arg2 = 0 ;
15695   bool result;
15696
15697   arg1 = (Dali::Property::Key *)jarg1;
15698   arg2 = (Dali::Property::Key *)jarg2;
15699   if (!arg2) {
15700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Key const & type is null", 0);
15701     return 0;
15702   }
15703   {
15704     try {
15705       result = (bool)(arg1)->operator !=((Dali::Property::Key const &)*arg2);
15706     } catch (std::out_of_range& e) {
15707       {
15708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15709       };
15710     } catch (std::exception& e) {
15711       {
15712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15713       };
15714     } catch (Dali::DaliException e) {
15715       {
15716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15717       };
15718     } catch (...) {
15719       {
15720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15721       };
15722     }
15723   }
15724
15725   jresult = result;
15726   return jresult;
15727 }
15728
15729
15730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Key(void * jarg1) {
15731   Dali::Property::Key *arg1 = (Dali::Property::Key *) 0 ;
15732
15733   arg1 = (Dali::Property::Key *)jarg1;
15734   {
15735     try {
15736       delete arg1;
15737     } catch (std::out_of_range& e) {
15738       {
15739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15740       };
15741     } catch (std::exception& e) {
15742       {
15743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15744       };
15745     } catch (Dali::DaliException e) {
15746       {
15747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15748       };
15749     } catch (...) {
15750       {
15751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15752       };
15753     }
15754   }
15755
15756 }
15757
15758
15759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_0() {
15760   void * jresult ;
15761   Dali::Property::Map *result = 0 ;
15762
15763   {
15764     try {
15765       result = (Dali::Property::Map *)new Dali::Property::Map();
15766     } catch (std::out_of_range& e) {
15767       {
15768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15769       };
15770     } catch (std::exception& e) {
15771       {
15772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15773       };
15774     } catch (Dali::DaliException e) {
15775       {
15776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15777       };
15778     } catch (...) {
15779       {
15780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15781       };
15782     }
15783   }
15784
15785   jresult = (void *)result;
15786   return jresult;
15787 }
15788
15789
15790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Map__SWIG_1(void * jarg1) {
15791   void * jresult ;
15792   Dali::Property::Map *arg1 = 0 ;
15793   Dali::Property::Map *result = 0 ;
15794
15795   arg1 = (Dali::Property::Map *)jarg1;
15796   if (!arg1) {
15797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
15798     return 0;
15799   }
15800   {
15801     try {
15802       result = (Dali::Property::Map *)new Dali::Property::Map((Dali::Property::Map const &)*arg1);
15803     } catch (std::out_of_range& e) {
15804       {
15805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15806       };
15807     } catch (std::exception& e) {
15808       {
15809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15810       };
15811     } catch (Dali::DaliException e) {
15812       {
15813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15814       };
15815     } catch (...) {
15816       {
15817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15818       };
15819     }
15820   }
15821
15822   jresult = (void *)result;
15823   return jresult;
15824 }
15825
15826
15827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Map(void * jarg1) {
15828   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15829
15830   arg1 = (Dali::Property::Map *)jarg1;
15831   {
15832     try {
15833       delete arg1;
15834     } catch (std::out_of_range& e) {
15835       {
15836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15837       };
15838     } catch (std::exception& e) {
15839       {
15840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15841       };
15842     } catch (Dali::DaliException e) {
15843       {
15844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15845       };
15846     } catch (...) {
15847       {
15848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15849       };
15850     }
15851   }
15852
15853 }
15854
15855
15856 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Property_Map_Count(void * jarg1) {
15857   unsigned long jresult ;
15858   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15859   Dali::Property::Map::SizeType result;
15860
15861   arg1 = (Dali::Property::Map *)jarg1;
15862   {
15863     try {
15864       result = ((Dali::Property::Map const *)arg1)->Count();
15865     } catch (std::out_of_range& e) {
15866       {
15867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15868       };
15869     } catch (std::exception& e) {
15870       {
15871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15872       };
15873     } catch (Dali::DaliException e) {
15874       {
15875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15876       };
15877     } catch (...) {
15878       {
15879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15880       };
15881     }
15882   }
15883
15884   jresult = (unsigned long)result;
15885   return jresult;
15886 }
15887
15888
15889 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Map_Empty(void * jarg1) {
15890   unsigned int jresult ;
15891   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15892   bool result;
15893
15894   arg1 = (Dali::Property::Map *)jarg1;
15895   {
15896     try {
15897       result = (bool)((Dali::Property::Map const *)arg1)->Empty();
15898     } catch (std::out_of_range& e) {
15899       {
15900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
15901       };
15902     } catch (std::exception& e) {
15903       {
15904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
15905       };
15906     } catch (Dali::DaliException e) {
15907       {
15908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
15909       };
15910     } catch (...) {
15911       {
15912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
15913       };
15914     }
15915   }
15916
15917   jresult = result;
15918   return jresult;
15919 }
15920
15921
15922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15923   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15924   char *arg2 = (char *) 0 ;
15925   Dali::Property::Value *arg3 = 0 ;
15926
15927   arg1 = (Dali::Property::Map *)jarg1;
15928   arg2 = (char *)jarg2;
15929   arg3 = (Dali::Property::Value *)jarg3;
15930   if (!arg3) {
15931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15932     return ;
15933   }
15934   {
15935     try {
15936       (arg1)->Insert((char const *)arg2,(Dali::Property::Value const &)*arg3);
15937     } catch (std::out_of_range& e) {
15938       {
15939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15940       };
15941     } catch (std::exception& e) {
15942       {
15943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15944       };
15945     } catch (Dali::DaliException e) {
15946       {
15947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15948       };
15949     } catch (...) {
15950       {
15951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15952       };
15953     }
15954   }
15955
15956 }
15957
15958
15959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Insert__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
15960   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15961   Dali::Property::Index arg2 ;
15962   Dali::Property::Value *arg3 = 0 ;
15963
15964   arg1 = (Dali::Property::Map *)jarg1;
15965   arg2 = (Dali::Property::Index)jarg2;
15966   arg3 = (Dali::Property::Value *)jarg3;
15967   if (!arg3) {
15968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
15969     return ;
15970   }
15971   {
15972     try {
15973       (arg1)->Insert(arg2,(Dali::Property::Value const &)*arg3);
15974     } catch (std::out_of_range& e) {
15975       {
15976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
15977       };
15978     } catch (std::exception& e) {
15979       {
15980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
15981       };
15982     } catch (Dali::DaliException e) {
15983       {
15984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
15985       };
15986     } catch (...) {
15987       {
15988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
15989       };
15990     }
15991   }
15992
15993 }
15994
15995
15996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
15997   void * jresult ;
15998   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
15999   char *arg2 = (char *) 0 ;
16000   Dali::Property::Value *arg3 = 0 ;
16001   Dali::Property::Map *result = 0 ;
16002
16003   arg1 = (Dali::Property::Map *)jarg1;
16004   arg2 = (char *)jarg2;
16005   arg3 = (Dali::Property::Value *)jarg3;
16006   if (!arg3) {
16007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16008     return 0;
16009   }
16010   {
16011     try {
16012       result = (Dali::Property::Map *) &(arg1)->Add((char const *)arg2,(Dali::Property::Value const &)*arg3);
16013     } catch (std::out_of_range& e) {
16014       {
16015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16016       };
16017     } catch (std::exception& e) {
16018       {
16019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16020       };
16021     } catch (Dali::DaliException e) {
16022       {
16023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16024       };
16025     } catch (...) {
16026       {
16027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16028       };
16029     }
16030   }
16031
16032   jresult = (void *)result;
16033   return jresult;
16034 }
16035
16036
16037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Add__SWIG_2(void * jarg1, int jarg2, void * jarg3) {
16038   void * jresult ;
16039   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16040   Dali::Property::Index arg2 ;
16041   Dali::Property::Value *arg3 = 0 ;
16042   Dali::Property::Map *result = 0 ;
16043
16044   arg1 = (Dali::Property::Map *)jarg1;
16045   arg2 = (Dali::Property::Index)jarg2;
16046   arg3 = (Dali::Property::Value *)jarg3;
16047   if (!arg3) {
16048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
16049     return 0;
16050   }
16051   {
16052     try {
16053       result = (Dali::Property::Map *) &(arg1)->Add(arg2,(Dali::Property::Value const &)*arg3);
16054     } catch (std::out_of_range& e) {
16055       {
16056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16057       };
16058     } catch (std::exception& e) {
16059       {
16060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16061       };
16062     } catch (Dali::DaliException e) {
16063       {
16064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16065       };
16066     } catch (...) {
16067       {
16068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16069       };
16070     }
16071   }
16072
16073   jresult = (void *)result;
16074   return jresult;
16075 }
16076
16077
16078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetValue(void * jarg1, unsigned long jarg2) {
16079   void * jresult ;
16080   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16081   Dali::Property::Map::SizeType arg2 ;
16082   Dali::Property::Value *result = 0 ;
16083
16084   arg1 = (Dali::Property::Map *)jarg1;
16085   arg2 = (Dali::Property::Map::SizeType)jarg2;
16086   {
16087     try {
16088       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->GetValue(arg2);
16089     } catch (std::out_of_range& e) {
16090       {
16091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16092       };
16093     } catch (std::exception& e) {
16094       {
16095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16096       };
16097     } catch (Dali::DaliException e) {
16098       {
16099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16100       };
16101     } catch (...) {
16102       {
16103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16104       };
16105     }
16106   }
16107
16108   jresult = (void *)result;
16109   return jresult;
16110 }
16111
16112
16113 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Property_Map_GetKey(void * jarg1, unsigned long jarg2) {
16114   char * jresult ;
16115   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16116   Dali::Property::Map::SizeType arg2 ;
16117   std::string *result = 0 ;
16118
16119   arg1 = (Dali::Property::Map *)jarg1;
16120   arg2 = (Dali::Property::Map::SizeType)jarg2;
16121   {
16122     try {
16123       result = (std::string *) &((Dali::Property::Map const *)arg1)->GetKey(arg2);
16124     } catch (std::out_of_range& e) {
16125       {
16126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16127       };
16128     } catch (std::exception& e) {
16129       {
16130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16131       };
16132     } catch (Dali::DaliException e) {
16133       {
16134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16135       };
16136     } catch (...) {
16137       {
16138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16139       };
16140     }
16141   }
16142
16143   jresult = SWIG_csharp_string_callback(result->c_str());
16144   return jresult;
16145 }
16146
16147
16148 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetKeyAt(void * jarg1, unsigned long jarg2) {
16149   void * jresult ;
16150   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16151   Dali::Property::Map::SizeType arg2 ;
16152   SwigValueWrapper< Dali::Property::Key > result;
16153
16154   arg1 = (Dali::Property::Map *)jarg1;
16155   arg2 = (Dali::Property::Map::SizeType)jarg2;
16156   {
16157     try {
16158       result = ((Dali::Property::Map const *)arg1)->GetKeyAt(arg2);
16159     } catch (std::out_of_range& e) {
16160       {
16161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16162       };
16163     } catch (std::exception& e) {
16164       {
16165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16166       };
16167     } catch (Dali::DaliException e) {
16168       {
16169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16170       };
16171     } catch (...) {
16172       {
16173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16174       };
16175     }
16176   }
16177
16178   jresult = new Dali::Property::Key((const Dali::Property::Key &)result);
16179   return jresult;
16180 }
16181
16182
16183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_GetPair(void * jarg1, unsigned long jarg2) {
16184   void * jresult ;
16185   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16186   Dali::Property::Map::SizeType arg2 ;
16187   StringValuePair *result = 0 ;
16188
16189   arg1 = (Dali::Property::Map *)jarg1;
16190   arg2 = (Dali::Property::Map::SizeType)jarg2;
16191   {
16192     try {
16193       result = (StringValuePair *) &((Dali::Property::Map const *)arg1)->GetPair(arg2);
16194     } catch (std::out_of_range& e) {
16195       {
16196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16197       };
16198     } catch (std::exception& e) {
16199       {
16200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16201       };
16202     } catch (Dali::DaliException e) {
16203       {
16204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16205       };
16206     } catch (...) {
16207       {
16208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16209       };
16210     }
16211   }
16212
16213   jresult = (void *)result;
16214   return jresult;
16215 }
16216
16217
16218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_0(void * jarg1, char * jarg2) {
16219   void * jresult ;
16220   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16221   char *arg2 = (char *) 0 ;
16222   Dali::Property::Value *result = 0 ;
16223
16224   arg1 = (Dali::Property::Map *)jarg1;
16225   arg2 = (char *)jarg2;
16226   {
16227     try {
16228       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((char const *)arg2);
16229     } catch (std::out_of_range& e) {
16230       {
16231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16232       };
16233     } catch (std::exception& e) {
16234       {
16235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16236       };
16237     } catch (Dali::DaliException e) {
16238       {
16239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16240       };
16241     } catch (...) {
16242       {
16243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16244       };
16245     }
16246   }
16247
16248   jresult = (void *)result;
16249   return jresult;
16250 }
16251
16252
16253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_2(void * jarg1, int jarg2) {
16254   void * jresult ;
16255   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16256   Dali::Property::Index arg2 ;
16257   Dali::Property::Value *result = 0 ;
16258
16259   arg1 = (Dali::Property::Map *)jarg1;
16260   arg2 = (Dali::Property::Index)jarg2;
16261   {
16262     try {
16263       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2);
16264     } catch (std::out_of_range& e) {
16265       {
16266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16267       };
16268     } catch (std::exception& e) {
16269       {
16270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16271       };
16272     } catch (Dali::DaliException e) {
16273       {
16274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16275       };
16276     } catch (...) {
16277       {
16278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16279       };
16280     }
16281   }
16282
16283   jresult = (void *)result;
16284   return jresult;
16285 }
16286
16287
16288 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_3(void * jarg1, int jarg2, char * jarg3) {
16289   void * jresult ;
16290   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16291   Dali::Property::Index arg2 ;
16292   std::string *arg3 = 0 ;
16293   Dali::Property::Value *result = 0 ;
16294
16295   arg1 = (Dali::Property::Map *)jarg1;
16296   arg2 = (Dali::Property::Index)jarg2;
16297   if (!jarg3) {
16298     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16299     return 0;
16300   }
16301   std::string arg3_str(jarg3);
16302   arg3 = &arg3_str;
16303   {
16304     try {
16305       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,(std::string const &)*arg3);
16306     } catch (std::out_of_range& e) {
16307       {
16308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16309       };
16310     } catch (std::exception& e) {
16311       {
16312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16313       };
16314     } catch (Dali::DaliException e) {
16315       {
16316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16317       };
16318     } catch (...) {
16319       {
16320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16321       };
16322     }
16323   }
16324
16325   jresult = (void *)result;
16326
16327   //argout typemap for const std::string&
16328
16329   return jresult;
16330 }
16331
16332
16333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_4(void * jarg1, char * jarg2, int jarg3) {
16334   void * jresult ;
16335   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16336   std::string *arg2 = 0 ;
16337   Dali::Property::Type arg3 ;
16338   Dali::Property::Value *result = 0 ;
16339
16340   arg1 = (Dali::Property::Map *)jarg1;
16341   if (!jarg2) {
16342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16343     return 0;
16344   }
16345   std::string arg2_str(jarg2);
16346   arg2 = &arg2_str;
16347   arg3 = (Dali::Property::Type)jarg3;
16348   {
16349     try {
16350       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find((std::string const &)*arg2,arg3);
16351     } catch (std::out_of_range& e) {
16352       {
16353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16354       };
16355     } catch (std::exception& e) {
16356       {
16357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16358       };
16359     } catch (Dali::DaliException e) {
16360       {
16361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16362       };
16363     } catch (...) {
16364       {
16365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16366       };
16367     }
16368   }
16369
16370   jresult = (void *)result;
16371
16372   //argout typemap for const std::string&
16373
16374   return jresult;
16375 }
16376
16377
16378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Find__SWIG_5(void * jarg1, int jarg2, int jarg3) {
16379   void * jresult ;
16380   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16381   Dali::Property::Index arg2 ;
16382   Dali::Property::Type arg3 ;
16383   Dali::Property::Value *result = 0 ;
16384
16385   arg1 = (Dali::Property::Map *)jarg1;
16386   arg2 = (Dali::Property::Index)jarg2;
16387   arg3 = (Dali::Property::Type)jarg3;
16388   {
16389     try {
16390       result = (Dali::Property::Value *)((Dali::Property::Map const *)arg1)->Find(arg2,arg3);
16391     } catch (std::out_of_range& e) {
16392       {
16393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16394       };
16395     } catch (std::exception& e) {
16396       {
16397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16398       };
16399     } catch (Dali::DaliException e) {
16400       {
16401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16402       };
16403     } catch (...) {
16404       {
16405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16406       };
16407     }
16408   }
16409
16410   jresult = (void *)result;
16411   return jresult;
16412 }
16413
16414
16415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Clear(void * jarg1) {
16416   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16417
16418   arg1 = (Dali::Property::Map *)jarg1;
16419   {
16420     try {
16421       (arg1)->Clear();
16422     } catch (std::out_of_range& e) {
16423       {
16424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16425       };
16426     } catch (std::exception& e) {
16427       {
16428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16429       };
16430     } catch (Dali::DaliException e) {
16431       {
16432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16433       };
16434     } catch (...) {
16435       {
16436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16437       };
16438     }
16439   }
16440
16441 }
16442
16443
16444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_Merge(void * jarg1, void * jarg2) {
16445   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16446   Dali::Property::Map *arg2 = 0 ;
16447
16448   arg1 = (Dali::Property::Map *)jarg1;
16449   arg2 = (Dali::Property::Map *)jarg2;
16450   if (!arg2) {
16451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16452     return ;
16453   }
16454   {
16455     try {
16456       (arg1)->Merge((Dali::Property::Map const &)*arg2);
16457     } catch (std::out_of_range& e) {
16458       {
16459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
16460       };
16461     } catch (std::exception& e) {
16462       {
16463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
16464       };
16465     } catch (Dali::DaliException e) {
16466       {
16467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
16468       };
16469     } catch (...) {
16470       {
16471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
16472       };
16473     }
16474   }
16475
16476 }
16477
16478
16479 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_0(void * jarg1, char * jarg2) {
16480   void * jresult ;
16481   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16482   std::string *arg2 = 0 ;
16483   Dali::Property::Value *result = 0 ;
16484
16485   arg1 = (Dali::Property::Map *)jarg1;
16486   if (!jarg2) {
16487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16488     return 0;
16489   }
16490   std::string arg2_str(jarg2);
16491   arg2 = &arg2_str;
16492   {
16493     try {
16494       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator []((std::string const &)*arg2);
16495     } catch (std::out_of_range& e) {
16496       {
16497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16498       };
16499     } catch (std::exception& e) {
16500       {
16501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16502       };
16503     } catch (Dali::DaliException e) {
16504       {
16505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16506       };
16507     } catch (...) {
16508       {
16509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16510       };
16511     }
16512   }
16513
16514   jresult = (void *)result;
16515
16516   //argout typemap for const std::string&
16517
16518   return jresult;
16519 }
16520
16521
16522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_ValueOfIndex__SWIG_2(void * jarg1, int jarg2) {
16523   void * jresult ;
16524   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16525   Dali::Property::Index arg2 ;
16526   Dali::Property::Value *result = 0 ;
16527
16528   arg1 = (Dali::Property::Map *)jarg1;
16529   arg2 = (Dali::Property::Index)jarg2;
16530   {
16531     try {
16532       result = (Dali::Property::Value *) &((Dali::Property::Map const *)arg1)->operator [](arg2);
16533     } catch (std::out_of_range& e) {
16534       {
16535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16536       };
16537     } catch (std::exception& e) {
16538       {
16539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16540       };
16541     } catch (Dali::DaliException e) {
16542       {
16543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16544       };
16545     } catch (...) {
16546       {
16547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16548       };
16549     }
16550   }
16551
16552   jresult = (void *)result;
16553   return jresult;
16554 }
16555
16556
16557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Map_Assign(void * jarg1, void * jarg2) {
16558   void * jresult ;
16559   Dali::Property::Map *arg1 = (Dali::Property::Map *) 0 ;
16560   Dali::Property::Map *arg2 = 0 ;
16561   Dali::Property::Map *result = 0 ;
16562
16563   arg1 = (Dali::Property::Map *)jarg1;
16564   arg2 = (Dali::Property::Map *)jarg2;
16565   if (!arg2) {
16566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
16567     return 0;
16568   }
16569   {
16570     try {
16571       result = (Dali::Property::Map *) &(arg1)->operator =((Dali::Property::Map const &)*arg2);
16572     } catch (std::out_of_range& e) {
16573       {
16574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16575       };
16576     } catch (std::exception& e) {
16577       {
16578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16579       };
16580     } catch (Dali::DaliException e) {
16581       {
16582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16583       };
16584     } catch (...) {
16585       {
16586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16587       };
16588     }
16589   }
16590
16591   jresult = (void *)result;
16592   return jresult;
16593 }
16594
16595
16596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_StringKey(void* jarg1, char* jarg2, void* jarg3) {
16597
16598   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16599
16600   if (!jarg2) {
16601     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
16602     return;
16603   }
16604   std::string arg2_str(jarg2);
16605   std::string* arg2 = &arg2_str;
16606
16607   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16608
16609   {
16610     try {
16611       arg1->operator[]((std::string const &)*arg2) = *arg3;
16612     } catch (std::out_of_range& e) {
16613       {
16614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16615       };
16616     } catch (std::exception& e) {
16617       {
16618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16619       };
16620     } catch (Dali::DaliException e) {
16621       {
16622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16623       };
16624     } catch (...) {
16625       {
16626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16627       };
16628     }
16629   }
16630 }
16631
16632
16633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Property_Map_SetValue_IntKey(void* jarg1, int jarg2, void* jarg3) {
16634
16635   Dali::Property::Map* arg1 = (Dali::Property::Map*)jarg1;
16636   Dali::Property::Index arg2 = (Dali::Property::Index)jarg2;
16637   Dali::Property::Value* arg3 = (Dali::Property::Value*)jarg3;
16638
16639   {
16640     try {
16641       arg1->operator[](arg2) = *arg3;
16642     } catch (std::out_of_range& e) {
16643       {
16644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
16645       };
16646     } catch (std::exception& e) {
16647       {
16648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
16649       };
16650     } catch (Dali::DaliException e) {
16651       {
16652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
16653       };
16654     } catch (...) {
16655       {
16656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
16657       };
16658     }
16659   }
16660 }
16661
16662
16663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_0() {
16664   void * jresult ;
16665   Dali::Property::Value *result = 0 ;
16666
16667   {
16668     try {
16669       result = (Dali::Property::Value *)new Dali::Property::Value();
16670     } catch (std::out_of_range& e) {
16671       {
16672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16673       };
16674     } catch (std::exception& e) {
16675       {
16676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16677       };
16678     } catch (Dali::DaliException e) {
16679       {
16680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16681       };
16682     } catch (...) {
16683       {
16684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16685       };
16686     }
16687   }
16688
16689   jresult = (void *)result;
16690   return jresult;
16691 }
16692
16693
16694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_1(unsigned int jarg1) {
16695   void * jresult ;
16696   bool arg1 ;
16697   Dali::Property::Value *result = 0 ;
16698
16699   arg1 = jarg1 ? true : false;
16700   {
16701     try {
16702       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16703     } catch (std::out_of_range& e) {
16704       {
16705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16706       };
16707     } catch (std::exception& e) {
16708       {
16709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16710       };
16711     } catch (Dali::DaliException e) {
16712       {
16713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16714       };
16715     } catch (...) {
16716       {
16717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16718       };
16719     }
16720   }
16721
16722   jresult = (void *)result;
16723   return jresult;
16724 }
16725
16726
16727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_2(int jarg1) {
16728   void * jresult ;
16729   int arg1 ;
16730   Dali::Property::Value *result = 0 ;
16731
16732   arg1 = (int)jarg1;
16733   {
16734     try {
16735       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16736     } catch (std::out_of_range& e) {
16737       {
16738         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16739       };
16740     } catch (std::exception& e) {
16741       {
16742         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16743       };
16744     } catch (Dali::DaliException e) {
16745       {
16746         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16747       };
16748     } catch (...) {
16749       {
16750         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16751       };
16752     }
16753   }
16754
16755   jresult = (void *)result;
16756   return jresult;
16757 }
16758
16759
16760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_3(float jarg1) {
16761   void * jresult ;
16762   float arg1 ;
16763   Dali::Property::Value *result = 0 ;
16764
16765   arg1 = (float)jarg1;
16766   {
16767     try {
16768       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
16769     } catch (std::out_of_range& e) {
16770       {
16771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16772       };
16773     } catch (std::exception& e) {
16774       {
16775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16776       };
16777     } catch (Dali::DaliException e) {
16778       {
16779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16780       };
16781     } catch (...) {
16782       {
16783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16784       };
16785     }
16786   }
16787
16788   jresult = (void *)result;
16789   return jresult;
16790 }
16791
16792
16793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_4(void * jarg1) {
16794   void * jresult ;
16795   Dali::Vector2 *arg1 = 0 ;
16796   Dali::Property::Value *result = 0 ;
16797
16798   arg1 = (Dali::Vector2 *)jarg1;
16799   if (!arg1) {
16800     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
16801     return 0;
16802   }
16803   {
16804     try {
16805       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector2 const &)*arg1);
16806     } catch (std::out_of_range& e) {
16807       {
16808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16809       };
16810     } catch (std::exception& e) {
16811       {
16812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16813       };
16814     } catch (Dali::DaliException e) {
16815       {
16816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16817       };
16818     } catch (...) {
16819       {
16820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16821       };
16822     }
16823   }
16824
16825   jresult = (void *)result;
16826   return jresult;
16827 }
16828
16829
16830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_5(void * jarg1) {
16831   void * jresult ;
16832   Dali::Vector3 *arg1 = 0 ;
16833   Dali::Property::Value *result = 0 ;
16834
16835   arg1 = (Dali::Vector3 *)jarg1;
16836   if (!arg1) {
16837     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
16838     return 0;
16839   }
16840   {
16841     try {
16842       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector3 const &)*arg1);
16843     } catch (std::out_of_range& e) {
16844       {
16845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16846       };
16847     } catch (std::exception& e) {
16848       {
16849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16850       };
16851     } catch (Dali::DaliException e) {
16852       {
16853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16854       };
16855     } catch (...) {
16856       {
16857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16858       };
16859     }
16860   }
16861
16862   jresult = (void *)result;
16863   return jresult;
16864 }
16865
16866
16867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_6(void * jarg1) {
16868   void * jresult ;
16869   Dali::Vector4 *arg1 = 0 ;
16870   Dali::Property::Value *result = 0 ;
16871
16872   arg1 = (Dali::Vector4 *)jarg1;
16873   if (!arg1) {
16874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
16875     return 0;
16876   }
16877   {
16878     try {
16879       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Vector4 const &)*arg1);
16880     } catch (std::out_of_range& e) {
16881       {
16882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16883       };
16884     } catch (std::exception& e) {
16885       {
16886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16887       };
16888     } catch (Dali::DaliException e) {
16889       {
16890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16891       };
16892     } catch (...) {
16893       {
16894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16895       };
16896     }
16897   }
16898
16899   jresult = (void *)result;
16900   return jresult;
16901 }
16902
16903
16904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_7(void * jarg1) {
16905   void * jresult ;
16906   Dali::Matrix3 *arg1 = 0 ;
16907   Dali::Property::Value *result = 0 ;
16908
16909   arg1 = (Dali::Matrix3 *)jarg1;
16910   if (!arg1) {
16911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 const & type is null", 0);
16912     return 0;
16913   }
16914   {
16915     try {
16916       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix3 const &)*arg1);
16917     } catch (std::out_of_range& e) {
16918       {
16919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16920       };
16921     } catch (std::exception& e) {
16922       {
16923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16924       };
16925     } catch (Dali::DaliException e) {
16926       {
16927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16928       };
16929     } catch (...) {
16930       {
16931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16932       };
16933     }
16934   }
16935
16936   jresult = (void *)result;
16937   return jresult;
16938 }
16939
16940
16941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_8(void * jarg1) {
16942   void * jresult ;
16943   Dali::Matrix *arg1 = 0 ;
16944   Dali::Property::Value *result = 0 ;
16945
16946   arg1 = (Dali::Matrix *)jarg1;
16947   if (!arg1) {
16948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix const & type is null", 0);
16949     return 0;
16950   }
16951   {
16952     try {
16953       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Matrix const &)*arg1);
16954     } catch (std::out_of_range& e) {
16955       {
16956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16957       };
16958     } catch (std::exception& e) {
16959       {
16960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16961       };
16962     } catch (Dali::DaliException e) {
16963       {
16964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
16965       };
16966     } catch (...) {
16967       {
16968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
16969       };
16970     }
16971   }
16972
16973   jresult = (void *)result;
16974   return jresult;
16975 }
16976
16977
16978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_9(void * jarg1) {
16979   void * jresult ;
16980   Dali::Rect< int > *arg1 = 0 ;
16981   Dali::Property::Value *result = 0 ;
16982
16983   arg1 = (Dali::Rect< int > *)jarg1;
16984   if (!arg1) {
16985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
16986     return 0;
16987   }
16988   {
16989     try {
16990       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Rect< int > const &)*arg1);
16991     } catch (std::out_of_range& e) {
16992       {
16993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
16994       };
16995     } catch (std::exception& e) {
16996       {
16997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
16998       };
16999     } catch (Dali::DaliException e) {
17000       {
17001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17002       };
17003     } catch (...) {
17004       {
17005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17006       };
17007     }
17008   }
17009
17010   jresult = (void *)result;
17011   return jresult;
17012 }
17013
17014
17015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_10(void * jarg1) {
17016   void * jresult ;
17017   Dali::AngleAxis *arg1 = 0 ;
17018   Dali::Property::Value *result = 0 ;
17019
17020   arg1 = (Dali::AngleAxis *)jarg1;
17021   if (!arg1) {
17022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis const & type is null", 0);
17023     return 0;
17024   }
17025   {
17026     try {
17027       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::AngleAxis const &)*arg1);
17028     } catch (std::out_of_range& e) {
17029       {
17030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17031       };
17032     } catch (std::exception& e) {
17033       {
17034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17035       };
17036     } catch (Dali::DaliException e) {
17037       {
17038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17039       };
17040     } catch (...) {
17041       {
17042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17043       };
17044     }
17045   }
17046
17047   jresult = (void *)result;
17048   return jresult;
17049 }
17050
17051
17052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_11(void * jarg1) {
17053   void * jresult ;
17054   Dali::Quaternion *arg1 = 0 ;
17055   Dali::Property::Value *result = 0 ;
17056
17057   arg1 = (Dali::Quaternion *)jarg1;
17058   if (!arg1) {
17059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
17060     return 0;
17061   }
17062   {
17063     try {
17064       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Quaternion const &)*arg1);
17065     } catch (std::out_of_range& e) {
17066       {
17067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17068       };
17069     } catch (std::exception& e) {
17070       {
17071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17072       };
17073     } catch (Dali::DaliException e) {
17074       {
17075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17076       };
17077     } catch (...) {
17078       {
17079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17080       };
17081     }
17082   }
17083
17084   jresult = (void *)result;
17085   return jresult;
17086 }
17087
17088
17089 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_12(char * jarg1) {
17090   void * jresult ;
17091   std::string *arg1 = 0 ;
17092   Dali::Property::Value *result = 0 ;
17093
17094   if (!jarg1) {
17095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
17096     return 0;
17097   }
17098   std::string arg1_str(jarg1);
17099   arg1 = &arg1_str;
17100   {
17101     try {
17102       result = (Dali::Property::Value *)new Dali::Property::Value((std::string const &)*arg1);
17103     } catch (std::out_of_range& e) {
17104       {
17105         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17106       };
17107     } catch (std::exception& e) {
17108       {
17109         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17110       };
17111     } catch (Dali::DaliException e) {
17112       {
17113         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17114       };
17115     } catch (...) {
17116       {
17117         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17118       };
17119     }
17120   }
17121
17122   jresult = (void *)result;
17123
17124   //argout typemap for const std::string&
17125
17126   return jresult;
17127 }
17128
17129
17130 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_14(void * jarg1) {
17131   void * jresult ;
17132   Dali::Property::Array *arg1 = 0 ;
17133   Dali::Property::Value *result = 0 ;
17134
17135   arg1 = (Dali::Property::Array *)jarg1;
17136   if (!arg1) {
17137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17138     return 0;
17139   }
17140   {
17141     try {
17142       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17143     } catch (std::out_of_range& e) {
17144       {
17145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17146       };
17147     } catch (std::exception& e) {
17148       {
17149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17150       };
17151     } catch (Dali::DaliException e) {
17152       {
17153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17154       };
17155     } catch (...) {
17156       {
17157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17158       };
17159     }
17160   }
17161
17162   jresult = (void *)result;
17163   return jresult;
17164 }
17165
17166
17167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_15(void * jarg1) {
17168   void * jresult ;
17169   Dali::Property::Map *arg1 = 0 ;
17170   Dali::Property::Value *result = 0 ;
17171
17172   arg1 = (Dali::Property::Map *)jarg1;
17173   if (!arg1) {
17174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17175     return 0;
17176   }
17177   {
17178     try {
17179       result = (Dali::Property::Value *)new Dali::Property::Value(*arg1);
17180     } catch (std::out_of_range& e) {
17181       {
17182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17183       };
17184     } catch (std::exception& e) {
17185       {
17186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17187       };
17188     } catch (Dali::DaliException e) {
17189       {
17190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17191       };
17192     } catch (...) {
17193       {
17194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17195       };
17196     }
17197   }
17198
17199   jresult = (void *)result;
17200   return jresult;
17201 }
17202
17203
17204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_16(void * jarg1) {
17205   void * jresult ;
17206   Extents *arg1 = 0 ;
17207   Dali::Property::Value *result = 0 ;
17208
17209   arg1 = (Extents *)jarg1;
17210   if (!arg1) {
17211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents const & type is null", 0);
17212     return 0;
17213   }
17214   {
17215     try {
17216       result = (Dali::Property::Value *)new Dali::Property::Value((Extents const &)*arg1);
17217     } catch (std::out_of_range& e) {
17218       {
17219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17220       };
17221     } catch (std::exception& e) {
17222       {
17223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17224       };
17225     } catch (...) {
17226       {
17227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17228       };
17229     }
17230   }
17231   jresult = (void *)result;
17232   return jresult;
17233 }
17234
17235
17236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_17(int jarg1) {
17237   void * jresult ;
17238   Dali::Property::Type arg1 ;
17239   Dali::Property::Value *result = 0 ;
17240
17241   arg1 = (Dali::Property::Type)jarg1;
17242   {
17243     try {
17244       result = (Dali::Property::Value *)new Dali::Property::Value(arg1);
17245     } catch (std::out_of_range& e) {
17246       {
17247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17248       };
17249     } catch (std::exception& e) {
17250       {
17251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17252       };
17253     } catch (Dali::DaliException e) {
17254       {
17255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17256       };
17257     } catch (...) {
17258       {
17259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17260       };
17261     }
17262   }
17263
17264   jresult = (void *)result;
17265   return jresult;
17266 }
17267
17268
17269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Property_Value__SWIG_18(void * jarg1) {
17270   void * jresult ;
17271   Dali::Property::Value *arg1 = 0 ;
17272   Dali::Property::Value *result = 0 ;
17273
17274   arg1 = (Dali::Property::Value *)jarg1;
17275   if (!arg1) {
17276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17277     return 0;
17278   }
17279   {
17280     try {
17281       result = (Dali::Property::Value *)new Dali::Property::Value((Dali::Property::Value const &)*arg1);
17282     } catch (std::out_of_range& e) {
17283       {
17284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17285       };
17286     } catch (std::exception& e) {
17287       {
17288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17289       };
17290     } catch (Dali::DaliException e) {
17291       {
17292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17293       };
17294     } catch (...) {
17295       {
17296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17297       };
17298     }
17299   }
17300
17301   jresult = (void *)result;
17302   return jresult;
17303 }
17304
17305
17306 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_Assign(void * jarg1, void * jarg2) {
17307   void * jresult ;
17308   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17309   Dali::Property::Value *arg2 = 0 ;
17310   Dali::Property::Value *result = 0 ;
17311
17312   arg1 = (Dali::Property::Value *)jarg1;
17313   arg2 = (Dali::Property::Value *)jarg2;
17314   if (!arg2) {
17315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
17316     return 0;
17317   }
17318   {
17319     try {
17320       result = (Dali::Property::Value *) &(arg1)->operator =((Dali::Property::Value const &)*arg2);
17321     } catch (std::out_of_range& e) {
17322       {
17323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17324       };
17325     } catch (std::exception& e) {
17326       {
17327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17328       };
17329     } catch (Dali::DaliException e) {
17330       {
17331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17332       };
17333     } catch (...) {
17334       {
17335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17336       };
17337     }
17338   }
17339
17340   jresult = (void *)result;
17341   return jresult;
17342 }
17343
17344
17345 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Property_Value(void * jarg1) {
17346   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17347
17348   arg1 = (Dali::Property::Value *)jarg1;
17349   {
17350     try {
17351       delete arg1;
17352     } catch (std::out_of_range& e) {
17353       {
17354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
17355       };
17356     } catch (std::exception& e) {
17357       {
17358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
17359       };
17360     } catch (Dali::DaliException e) {
17361       {
17362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
17363       };
17364     } catch (...) {
17365       {
17366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
17367       };
17368     }
17369   }
17370
17371 }
17372
17373
17374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Property_Value_GetType(void * jarg1) {
17375   int jresult ;
17376   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17377   Dali::Property::Type result;
17378
17379   arg1 = (Dali::Property::Value *)jarg1;
17380   {
17381     try {
17382       result = (Dali::Property::Type)((Dali::Property::Value const *)arg1)->GetType();
17383     } catch (std::out_of_range& e) {
17384       {
17385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17386       };
17387     } catch (std::exception& e) {
17388       {
17389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17390       };
17391     } catch (Dali::DaliException e) {
17392       {
17393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17394       };
17395     } catch (...) {
17396       {
17397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17398       };
17399     }
17400   }
17401
17402   jresult = (int)result;
17403   return jresult;
17404 }
17405
17406
17407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_1(void * jarg1, unsigned int * jarg2) {
17408   unsigned int jresult ;
17409   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17410   bool *arg2 = 0 ;
17411   bool result;
17412
17413   arg1 = (Dali::Property::Value *)jarg1;
17414   arg2 = (bool *)jarg2;
17415   {
17416     try {
17417       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17418     } catch (std::out_of_range& e) {
17419       {
17420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17421       };
17422     } catch (std::exception& e) {
17423       {
17424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17425       };
17426     } catch (Dali::DaliException e) {
17427       {
17428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17429       };
17430     } catch (...) {
17431       {
17432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17433       };
17434     }
17435   }
17436
17437   jresult = result;
17438   return jresult;
17439 }
17440
17441
17442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_2(void * jarg1, float * jarg2) {
17443   unsigned int jresult ;
17444   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17445   float *arg2 = 0 ;
17446   bool result;
17447
17448   arg1 = (Dali::Property::Value *)jarg1;
17449   arg2 = (float *)jarg2;
17450   {
17451     try {
17452       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17453     } catch (std::out_of_range& e) {
17454       {
17455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17456       };
17457     } catch (std::exception& e) {
17458       {
17459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17460       };
17461     } catch (Dali::DaliException e) {
17462       {
17463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17464       };
17465     } catch (...) {
17466       {
17467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17468       };
17469     }
17470   }
17471
17472   jresult = result;
17473   return jresult;
17474 }
17475
17476
17477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_3(void * jarg1, int * jarg2) {
17478   unsigned int jresult ;
17479   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17480   int *arg2 = 0 ;
17481   bool result;
17482
17483   arg1 = (Dali::Property::Value *)jarg1;
17484   arg2 = (int *)jarg2;
17485   {
17486     try {
17487       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17488     } catch (std::out_of_range& e) {
17489       {
17490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17491       };
17492     } catch (std::exception& e) {
17493       {
17494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17495       };
17496     } catch (Dali::DaliException e) {
17497       {
17498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17499       };
17500     } catch (...) {
17501       {
17502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17503       };
17504     }
17505   }
17506
17507   jresult = result;
17508   return jresult;
17509 }
17510
17511
17512 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_4(void * jarg1, void * jarg2) {
17513   unsigned int jresult ;
17514   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17515   Dali::Rect< int > *arg2 = 0 ;
17516   bool result;
17517
17518   arg1 = (Dali::Property::Value *)jarg1;
17519   arg2 = (Dali::Rect< int > *)jarg2;
17520   if (!arg2) {
17521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > & type is null", 0);
17522     return 0;
17523   }
17524   {
17525     try {
17526       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17527     } catch (std::out_of_range& e) {
17528       {
17529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17530       };
17531     } catch (std::exception& e) {
17532       {
17533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17534       };
17535     } catch (Dali::DaliException e) {
17536       {
17537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17538       };
17539     } catch (...) {
17540       {
17541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17542       };
17543     }
17544   }
17545
17546   jresult = result;
17547   return jresult;
17548 }
17549
17550
17551 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_5(void * jarg1, void * jarg2) {
17552   unsigned int jresult ;
17553   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17554   Dali::Vector2 *arg2 = 0 ;
17555   bool result;
17556
17557   arg1 = (Dali::Property::Value *)jarg1;
17558   arg2 = (Dali::Vector2 *)jarg2;
17559   if (!arg2) {
17560     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
17561     return 0;
17562   }
17563   {
17564     try {
17565       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17566     } catch (std::out_of_range& e) {
17567       {
17568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17569       };
17570     } catch (std::exception& e) {
17571       {
17572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17573       };
17574     } catch (Dali::DaliException e) {
17575       {
17576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17577       };
17578     } catch (...) {
17579       {
17580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17581       };
17582     }
17583   }
17584
17585   jresult = result;
17586   return jresult;
17587 }
17588
17589
17590 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_6(void * jarg1, void * jarg2) {
17591   unsigned int jresult ;
17592   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17593   Dali::Vector3 *arg2 = 0 ;
17594   bool result;
17595
17596   arg1 = (Dali::Property::Value *)jarg1;
17597   arg2 = (Dali::Vector3 *)jarg2;
17598   if (!arg2) {
17599     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
17600     return 0;
17601   }
17602   {
17603     try {
17604       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17605     } catch (std::out_of_range& e) {
17606       {
17607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17608       };
17609     } catch (std::exception& e) {
17610       {
17611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17612       };
17613     } catch (Dali::DaliException e) {
17614       {
17615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17616       };
17617     } catch (...) {
17618       {
17619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17620       };
17621     }
17622   }
17623
17624   jresult = result;
17625   return jresult;
17626 }
17627
17628
17629 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_7(void * jarg1, void * jarg2) {
17630   unsigned int jresult ;
17631   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17632   Dali::Vector4 *arg2 = 0 ;
17633   bool result;
17634
17635   arg1 = (Dali::Property::Value *)jarg1;
17636   arg2 = (Dali::Vector4 *)jarg2;
17637   if (!arg2) {
17638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 & type is null", 0);
17639     return 0;
17640   }
17641   {
17642     try {
17643       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17644     } catch (std::out_of_range& e) {
17645       {
17646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17647       };
17648     } catch (std::exception& e) {
17649       {
17650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17651       };
17652     } catch (Dali::DaliException e) {
17653       {
17654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17655       };
17656     } catch (...) {
17657       {
17658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17659       };
17660     }
17661   }
17662
17663   jresult = result;
17664   return jresult;
17665 }
17666
17667
17668 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_8(void * jarg1, void * jarg2) {
17669   unsigned int jresult ;
17670   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17671   Dali::Matrix3 *arg2 = 0 ;
17672   bool result;
17673
17674   arg1 = (Dali::Property::Value *)jarg1;
17675   arg2 = (Dali::Matrix3 *)jarg2;
17676   if (!arg2) {
17677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix3 & type is null", 0);
17678     return 0;
17679   }
17680   {
17681     try {
17682       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17683     } catch (std::out_of_range& e) {
17684       {
17685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17686       };
17687     } catch (std::exception& e) {
17688       {
17689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17690       };
17691     } catch (Dali::DaliException e) {
17692       {
17693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17694       };
17695     } catch (...) {
17696       {
17697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17698       };
17699     }
17700   }
17701
17702   jresult = result;
17703   return jresult;
17704 }
17705
17706
17707 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_9(void * jarg1, void * jarg2) {
17708   unsigned int jresult ;
17709   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17710   Dali::Matrix *arg2 = 0 ;
17711   bool result;
17712
17713   arg1 = (Dali::Property::Value *)jarg1;
17714   arg2 = (Dali::Matrix *)jarg2;
17715   if (!arg2) {
17716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Matrix & type is null", 0);
17717     return 0;
17718   }
17719   {
17720     try {
17721       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17722     } catch (std::out_of_range& e) {
17723       {
17724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17725       };
17726     } catch (std::exception& e) {
17727       {
17728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17729       };
17730     } catch (Dali::DaliException e) {
17731       {
17732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17733       };
17734     } catch (...) {
17735       {
17736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17737       };
17738     }
17739   }
17740
17741   jresult = result;
17742   return jresult;
17743 }
17744
17745
17746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_10(void * jarg1, void * jarg2) {
17747   unsigned int jresult ;
17748   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17749   Dali::AngleAxis *arg2 = 0 ;
17750   bool result;
17751
17752   arg1 = (Dali::Property::Value *)jarg1;
17753   arg2 = (Dali::AngleAxis *)jarg2;
17754   if (!arg2) {
17755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::AngleAxis & type is null", 0);
17756     return 0;
17757   }
17758   {
17759     try {
17760       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17761     } catch (std::out_of_range& e) {
17762       {
17763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17764       };
17765     } catch (std::exception& e) {
17766       {
17767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17768       };
17769     } catch (Dali::DaliException e) {
17770       {
17771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17772       };
17773     } catch (...) {
17774       {
17775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17776       };
17777     }
17778   }
17779
17780   jresult = result;
17781   return jresult;
17782 }
17783
17784
17785 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_11(void * jarg1, void * jarg2) {
17786   unsigned int jresult ;
17787   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17788   Dali::Quaternion *arg2 = 0 ;
17789   bool result;
17790
17791   arg1 = (Dali::Property::Value *)jarg1;
17792   arg2 = (Dali::Quaternion *)jarg2;
17793   if (!arg2) {
17794     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion & type is null", 0);
17795     return 0;
17796   }
17797   {
17798     try {
17799       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17800     } catch (std::out_of_range& e) {
17801       {
17802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17803       };
17804     } catch (std::exception& e) {
17805       {
17806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17807       };
17808     } catch (Dali::DaliException e) {
17809       {
17810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17811       };
17812     } catch (...) {
17813       {
17814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17815       };
17816     }
17817   }
17818
17819   jresult = result;
17820   return jresult;
17821 }
17822
17823
17824 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_12(void * jarg1, char** jarg2) {
17825   unsigned int jresult ;
17826   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17827   std::string *arg2 = 0 ;
17828   bool result;
17829
17830   arg1 = (Dali::Property::Value *)jarg1;
17831
17832   //typemap in
17833   std::string temp;
17834   arg2 = &temp;
17835
17836   {
17837     try {
17838       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17839     } catch (std::out_of_range& e) {
17840       {
17841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17842       };
17843     } catch (std::exception& e) {
17844       {
17845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17846       };
17847     } catch (Dali::DaliException e) {
17848       {
17849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17850       };
17851     } catch (...) {
17852       {
17853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17854       };
17855     }
17856   }
17857
17858   jresult = result;
17859
17860   //Typemap argout in c++ file.
17861   //This will convert c++ string to c# string
17862   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
17863
17864   return jresult;
17865 }
17866
17867
17868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_13(void * jarg1, void * jarg2) {
17869   unsigned int jresult ;
17870   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17871   Dali::Property::Array *arg2 = 0 ;
17872   bool result;
17873
17874   arg1 = (Dali::Property::Value *)jarg1;
17875   arg2 = (Dali::Property::Array *)jarg2;
17876   if (!arg2) {
17877     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array & type is null", 0);
17878     return 0;
17879   }
17880   {
17881     try {
17882       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17883     } catch (std::out_of_range& e) {
17884       {
17885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17886       };
17887     } catch (std::exception& e) {
17888       {
17889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17890       };
17891     } catch (Dali::DaliException e) {
17892       {
17893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17894       };
17895     } catch (...) {
17896       {
17897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17898       };
17899     }
17900   }
17901
17902   jresult = result;
17903   return jresult;
17904 }
17905
17906
17907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_14(void * jarg1, void * jarg2) {
17908   unsigned int jresult ;
17909   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17910   Dali::Property::Map *arg2 = 0 ;
17911   bool result;
17912
17913   arg1 = (Dali::Property::Value *)jarg1;
17914   arg2 = (Dali::Property::Map *)jarg2;
17915   if (!arg2) {
17916     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
17917     return 0;
17918   }
17919   {
17920     try {
17921       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17922     } catch (std::out_of_range& e) {
17923       {
17924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17925       };
17926     } catch (std::exception& e) {
17927       {
17928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17929       };
17930     } catch (Dali::DaliException e) {
17931       {
17932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
17933       };
17934     } catch (...) {
17935       {
17936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17937       };
17938     }
17939   }
17940
17941   jresult = result;
17942   return jresult;
17943 }
17944
17945
17946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Property_Value_Get__SWIG_15(void * jarg1, void * jarg2) {
17947   unsigned int jresult ;
17948   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17949   Extents *arg2 = 0 ;
17950   bool result;
17951
17952   arg1 = (Dali::Property::Value *)jarg1;
17953   arg2 = (Extents *)jarg2;
17954   if (!arg2) {
17955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Extents & type is null", 0);
17956     return 0;
17957   }
17958   {
17959     try {
17960       result = (bool)((Dali::Property::Value const *)arg1)->Get(*arg2);
17961     } catch (std::out_of_range& e) {
17962       {
17963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17964       };
17965     } catch (std::exception& e) {
17966       {
17967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17968       };
17969     } catch (...) {
17970       {
17971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
17972       };
17973     }
17974   }
17975   jresult = result;
17976   return jresult;
17977 }
17978
17979
17980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetArray(void * jarg1) {
17981   void * jresult ;
17982   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
17983   Dali::Property::Array *result = 0 ;
17984
17985   arg1 = (Dali::Property::Value *)jarg1;
17986   {
17987     try {
17988       result = (Dali::Property::Array *)((Dali::Property::Value const *)arg1)->GetArray();
17989     } catch (std::out_of_range& e) {
17990       {
17991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
17992       };
17993     } catch (std::exception& e) {
17994       {
17995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
17996       };
17997     } catch (Dali::DaliException e) {
17998       {
17999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18000       };
18001     } catch (...) {
18002       {
18003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18004       };
18005     }
18006   }
18007
18008   jresult = (void *)result;
18009   return jresult;
18010 }
18011
18012
18013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Property_Value_GetMap(void * jarg1) {
18014   void * jresult ;
18015   Dali::Property::Value *arg1 = (Dali::Property::Value *) 0 ;
18016   Dali::Property::Map *result = 0 ;
18017
18018   arg1 = (Dali::Property::Value *)jarg1;
18019   {
18020     try {
18021       result = (Dali::Property::Map *)((Dali::Property::Value const *)arg1)->GetMap();
18022     } catch (std::out_of_range& e) {
18023       {
18024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18025       };
18026     } catch (std::exception& e) {
18027       {
18028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18029       };
18030     } catch (Dali::DaliException e) {
18031       {
18032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18033       };
18034     } catch (...) {
18035       {
18036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18037       };
18038     }
18039   }
18040
18041   jresult = (void *)result;
18042   return jresult;
18043 }
18044
18045
18046 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetName(int jarg1) {
18047   char * jresult ;
18048   Dali::Property::Type arg1 ;
18049   char *result = 0 ;
18050
18051   arg1 = (Dali::Property::Type)jarg1;
18052   {
18053     try {
18054       result = (char *)Dali::PropertyTypes::GetName(arg1);
18055     } catch (std::out_of_range& e) {
18056       {
18057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18058       };
18059     } catch (std::exception& e) {
18060       {
18061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18062       };
18063     } catch (Dali::DaliException e) {
18064       {
18065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18066       };
18067     } catch (...) {
18068       {
18069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18070       };
18071     }
18072   }
18073
18074   jresult = SWIG_csharp_string_callback((const char *)result);
18075   return jresult;
18076 }
18077
18078
18079 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18080   unsigned int jresult ;
18081   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18082   std::string *arg2 = 0 ;
18083   Dali::Property::Map *arg3 = 0 ;
18084   bool result;
18085
18086   arg1 = (Dali::BaseObject *)jarg1;
18087   if (!jarg2) {
18088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18089     return 0;
18090   }
18091   std::string arg2_str(jarg2);
18092   arg2 = &arg2_str;
18093   arg3 = (Dali::Property::Map *)jarg3;
18094   if (!arg3) {
18095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18096     return 0;
18097   }
18098   {
18099     try {
18100       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18101     } catch (std::out_of_range& e) {
18102       {
18103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18104       };
18105     } catch (std::exception& e) {
18106       {
18107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18108       };
18109     } catch (Dali::DaliException e) {
18110       {
18111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18112       };
18113     } catch (...) {
18114       {
18115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18116       };
18117     }
18118   }
18119
18120   jresult = result;
18121
18122   //argout typemap for const std::string&
18123
18124   return jresult;
18125 }
18126
18127
18128 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeName(void * jarg1) {
18129   char * jresult ;
18130   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18131   std::string *result = 0 ;
18132
18133   arg1 = (Dali::BaseObject *)jarg1;
18134   {
18135     try {
18136       result = (std::string *) &((Dali::BaseObject const *)arg1)->GetTypeName();
18137     } catch (std::out_of_range& e) {
18138       {
18139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18140       };
18141     } catch (std::exception& e) {
18142       {
18143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18144       };
18145     } catch (Dali::DaliException e) {
18146       {
18147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18148       };
18149     } catch (...) {
18150       {
18151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18152       };
18153     }
18154   }
18155
18156   jresult = SWIG_csharp_string_callback(result->c_str());
18157   return jresult;
18158 }
18159
18160
18161 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_GetTypeInfo(void * jarg1, void * jarg2) {
18162   unsigned int jresult ;
18163   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18164   Dali::TypeInfo *arg2 = 0 ;
18165   bool result;
18166
18167   arg1 = (Dali::BaseObject *)jarg1;
18168   arg2 = (Dali::TypeInfo *)jarg2;
18169   if (!arg2) {
18170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18171     return 0;
18172   }
18173   {
18174     try {
18175       result = (bool)((Dali::BaseObject const *)arg1)->GetTypeInfo(*arg2);
18176     } catch (std::out_of_range& e) {
18177       {
18178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18179       };
18180     } catch (std::exception& e) {
18181       {
18182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18183       };
18184     } catch (Dali::DaliException e) {
18185       {
18186         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18187       };
18188     } catch (...) {
18189       {
18190         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18191       };
18192     }
18193   }
18194
18195   jresult = result;
18196   return jresult;
18197 }
18198
18199
18200 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseObject_DoConnectSignal(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
18201   unsigned int jresult ;
18202   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18203   ConnectionTrackerInterface *arg2 = (ConnectionTrackerInterface *) 0 ;
18204   std::string *arg3 = 0 ;
18205   FunctorDelegate *arg4 = (FunctorDelegate *) 0 ;
18206   bool result;
18207
18208   arg1 = (Dali::BaseObject *)jarg1;
18209   arg2 = (ConnectionTrackerInterface *)jarg2;
18210   if (!jarg3) {
18211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18212     return 0;
18213   }
18214   std::string arg3_str(jarg3);
18215   arg3 = &arg3_str;
18216   arg4 = (FunctorDelegate *)jarg4;
18217   {
18218     try {
18219       result = (bool)(arg1)->DoConnectSignal(arg2,(std::string const &)*arg3,arg4);
18220     } catch (std::out_of_range& e) {
18221       {
18222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18223       };
18224     } catch (std::exception& e) {
18225       {
18226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18227       };
18228     } catch (Dali::DaliException e) {
18229       {
18230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18231       };
18232     } catch (...) {
18233       {
18234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18235       };
18236     }
18237   }
18238
18239   jresult = result;
18240
18241   //argout typemap for const std::string&
18242
18243   return jresult;
18244 }
18245
18246
18247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation(void * jarg1) {
18248   void * jresult ;
18249   Dali::BaseHandle *arg1 = 0 ;
18250   Dali::BaseObject *result = 0 ;
18251
18252   arg1 = (Dali::BaseHandle *)jarg1;
18253   if (!arg1) {
18254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18255     return 0;
18256   }
18257   {
18258     try {
18259       result = (Dali::BaseObject *) &Dali::GetImplementation((Dali::BaseHandle const &)*arg1);
18260     } catch (std::out_of_range& e) {
18261       {
18262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18263       };
18264     } catch (std::exception& e) {
18265       {
18266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18267       };
18268     } catch (Dali::DaliException e) {
18269       {
18270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18271       };
18272     } catch (...) {
18273       {
18274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18275       };
18276     }
18277   }
18278
18279   jresult = (void *)result;
18280   return jresult;
18281 }
18282
18283
18284 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_0(void * jarg1) {
18285   void * jresult ;
18286   Dali::BaseObject *arg1 = (Dali::BaseObject *) 0 ;
18287   Dali::BaseHandle *result = 0 ;
18288
18289   arg1 = (Dali::BaseObject *)jarg1;
18290   {
18291     try {
18292       result = (Dali::BaseHandle *)new Dali::BaseHandle(arg1);
18293     } catch (std::out_of_range& e) {
18294       {
18295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18296       };
18297     } catch (std::exception& e) {
18298       {
18299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18300       };
18301     } catch (Dali::DaliException e) {
18302       {
18303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18304       };
18305     } catch (...) {
18306       {
18307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18308       };
18309     }
18310   }
18311
18312   jresult = (void *)result;
18313   return jresult;
18314 }
18315
18316
18317 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_1() {
18318   void * jresult ;
18319   Dali::BaseHandle *result = 0 ;
18320
18321   {
18322     try {
18323       result = (Dali::BaseHandle *)new Dali::BaseHandle();
18324     } catch (std::out_of_range& e) {
18325       {
18326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18327       };
18328     } catch (std::exception& e) {
18329       {
18330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18331       };
18332     } catch (Dali::DaliException e) {
18333       {
18334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18335       };
18336     } catch (...) {
18337       {
18338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18339       };
18340     }
18341   }
18342
18343   jresult = (void *)result;
18344   return jresult;
18345 }
18346
18347
18348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_BaseHandle(void * jarg1) {
18349   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18350
18351   arg1 = (Dali::BaseHandle *)jarg1;
18352   {
18353     try {
18354       delete arg1;
18355     } catch (std::out_of_range& e) {
18356       {
18357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18358       };
18359     } catch (std::exception& e) {
18360       {
18361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18362       };
18363     } catch (Dali::DaliException e) {
18364       {
18365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18366       };
18367     } catch (...) {
18368       {
18369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18370       };
18371     }
18372   }
18373
18374 }
18375
18376
18377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_BaseHandle__SWIG_2(void * jarg1) {
18378   void * jresult ;
18379   Dali::BaseHandle *arg1 = 0 ;
18380   Dali::BaseHandle *result = 0 ;
18381
18382   arg1 = (Dali::BaseHandle *)jarg1;
18383   if (!arg1) {
18384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18385     return 0;
18386   }
18387   {
18388     try {
18389       result = (Dali::BaseHandle *)new Dali::BaseHandle((Dali::BaseHandle const &)*arg1);
18390     } catch (std::out_of_range& e) {
18391       {
18392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18393       };
18394     } catch (std::exception& e) {
18395       {
18396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18397       };
18398     } catch (Dali::DaliException e) {
18399       {
18400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18401       };
18402     } catch (...) {
18403       {
18404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18405       };
18406     }
18407   }
18408
18409   jresult = (void *)result;
18410   return jresult;
18411 }
18412
18413
18414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_Assign(void * jarg1, void * jarg2) {
18415   void * jresult ;
18416   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18417   Dali::BaseHandle *arg2 = 0 ;
18418   Dali::BaseHandle *result = 0 ;
18419
18420   arg1 = (Dali::BaseHandle *)jarg1;
18421   arg2 = (Dali::BaseHandle *)jarg2;
18422   if (!arg2) {
18423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18424     return 0;
18425   }
18426   {
18427     try {
18428       result = (Dali::BaseHandle *) &(arg1)->operator =((Dali::BaseHandle const &)*arg2);
18429     } catch (std::out_of_range& e) {
18430       {
18431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18432       };
18433     } catch (std::exception& e) {
18434       {
18435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18436       };
18437     } catch (Dali::DaliException e) {
18438       {
18439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18440       };
18441     } catch (...) {
18442       {
18443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18444       };
18445     }
18446   }
18447
18448   jresult = (void *)result;
18449   return jresult;
18450 }
18451
18452
18453 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_DoAction(void * jarg1, char * jarg2, void * jarg3) {
18454   unsigned int jresult ;
18455   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18456   std::string *arg2 = 0 ;
18457   Dali::Property::Map *arg3 = 0 ;
18458   bool result;
18459
18460   arg1 = (Dali::BaseHandle *)jarg1;
18461   if (!jarg2) {
18462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
18463     return 0;
18464   }
18465   std::string arg2_str(jarg2);
18466   arg2 = &arg2_str;
18467   arg3 = (Dali::Property::Map *)jarg3;
18468   if (!arg3) {
18469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
18470     return 0;
18471   }
18472   {
18473     try {
18474       result = (bool)(arg1)->DoAction((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
18475     } catch (std::out_of_range& e) {
18476       {
18477         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18478       };
18479     } catch (std::exception& e) {
18480       {
18481         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18482       };
18483     } catch (Dali::DaliException e) {
18484       {
18485         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18486       };
18487     } catch (...) {
18488       {
18489         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18490       };
18491     }
18492   }
18493
18494   jresult = result;
18495
18496   //argout typemap for const std::string&
18497
18498   return jresult;
18499 }
18500
18501
18502 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeName(void * jarg1) {
18503   char * jresult ;
18504   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18505   std::string *result = 0 ;
18506
18507   arg1 = (Dali::BaseHandle *)jarg1;
18508   {
18509     try {
18510       result = (std::string *) &((Dali::BaseHandle const *)arg1)->GetTypeName();
18511     } catch (std::out_of_range& e) {
18512       {
18513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18514       };
18515     } catch (std::exception& e) {
18516       {
18517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18518       };
18519     } catch (Dali::DaliException e) {
18520       {
18521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18522       };
18523     } catch (...) {
18524       {
18525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18526       };
18527     }
18528   }
18529
18530   jresult = SWIG_csharp_string_callback(result->c_str());
18531   return jresult;
18532 }
18533
18534
18535 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_GetTypeInfo(void * jarg1, void * jarg2) {
18536   unsigned int jresult ;
18537   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18538   Dali::TypeInfo *arg2 = 0 ;
18539   bool result;
18540
18541   arg1 = (Dali::BaseHandle *)jarg1;
18542   arg2 = (Dali::TypeInfo *)jarg2;
18543   if (!arg2) {
18544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo & type is null", 0);
18545     return 0;
18546   }
18547   {
18548     try {
18549       result = (bool)((Dali::BaseHandle const *)arg1)->GetTypeInfo(*arg2);
18550     } catch (std::out_of_range& e) {
18551       {
18552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18553       };
18554     } catch (std::exception& e) {
18555       {
18556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18557       };
18558     } catch (Dali::DaliException e) {
18559       {
18560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18561       };
18562     } catch (...) {
18563       {
18564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18565       };
18566     }
18567   }
18568
18569   jresult = result;
18570   return jresult;
18571 }
18572
18573
18574 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetBaseObject__SWIG_0(void * jarg1) {
18575   void * jresult ;
18576   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18577   Dali::BaseObject *result = 0 ;
18578
18579   arg1 = (Dali::BaseHandle *)jarg1;
18580   {
18581     try {
18582       result = (Dali::BaseObject *) &(arg1)->GetBaseObject();
18583     } catch (std::out_of_range& e) {
18584       {
18585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18586       };
18587     } catch (std::exception& e) {
18588       {
18589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18590       };
18591     } catch (Dali::DaliException e) {
18592       {
18593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18594       };
18595     } catch (...) {
18596       {
18597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18598       };
18599     }
18600   }
18601
18602   jresult = (void *)result;
18603   return jresult;
18604 }
18605
18606
18607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_BaseHandle_Reset(void * jarg1) {
18608   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18609
18610   arg1 = (Dali::BaseHandle *)jarg1;
18611   {
18612     try {
18613       (arg1)->Reset();
18614     } catch (std::out_of_range& e) {
18615       {
18616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18617       };
18618     } catch (std::exception& e) {
18619       {
18620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18621       };
18622     } catch (Dali::DaliException e) {
18623       {
18624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18625       };
18626     } catch (...) {
18627       {
18628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18629       };
18630     }
18631   }
18632
18633 }
18634
18635
18636 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_EqualTo(void * jarg1, void * jarg2) {
18637   unsigned int jresult ;
18638   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18639   Dali::BaseHandle *arg2 = 0 ;
18640   bool result;
18641
18642   arg1 = (Dali::BaseHandle *)jarg1;
18643   arg2 = (Dali::BaseHandle *)jarg2;
18644   if (!arg2) {
18645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18646     return 0;
18647   }
18648   {
18649     try {
18650       result = (bool)((Dali::BaseHandle const *)arg1)->operator ==((Dali::BaseHandle const &)*arg2);
18651     } catch (std::out_of_range& e) {
18652       {
18653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18654       };
18655     } catch (std::exception& e) {
18656       {
18657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18658       };
18659     } catch (Dali::DaliException e) {
18660       {
18661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18662       };
18663     } catch (...) {
18664       {
18665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18666       };
18667     }
18668   }
18669
18670   jresult = result;
18671   return jresult;
18672 }
18673
18674
18675 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_NotEqualTo(void * jarg1, void * jarg2) {
18676   unsigned int jresult ;
18677   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18678   Dali::BaseHandle *arg2 = 0 ;
18679   bool result;
18680
18681   arg1 = (Dali::BaseHandle *)jarg1;
18682   arg2 = (Dali::BaseHandle *)jarg2;
18683   if (!arg2) {
18684     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18685     return 0;
18686   }
18687   {
18688     try {
18689       result = (bool)((Dali::BaseHandle const *)arg1)->operator !=((Dali::BaseHandle const &)*arg2);
18690     } catch (std::out_of_range& e) {
18691       {
18692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18693       };
18694     } catch (std::exception& e) {
18695       {
18696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18697       };
18698     } catch (Dali::DaliException e) {
18699       {
18700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18701       };
18702     } catch (...) {
18703       {
18704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18705       };
18706     }
18707   }
18708
18709   jresult = result;
18710   return jresult;
18711 }
18712
18713
18714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BaseHandle_GetObjectPtr(void * jarg1) {
18715   void * jresult ;
18716   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18717   Dali::RefObject *result = 0 ;
18718
18719   arg1 = (Dali::BaseHandle *)jarg1;
18720   {
18721     try {
18722       result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
18723     } catch (std::out_of_range& e) {
18724       {
18725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18726       };
18727     } catch (std::exception& e) {
18728       {
18729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18730       };
18731     } catch (Dali::DaliException e) {
18732       {
18733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18734       };
18735     } catch (...) {
18736       {
18737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18738       };
18739     }
18740   }
18741
18742   jresult = (void *)result;
18743   return jresult;
18744 }
18745
18746
18747 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_HasBody(void * jarg1) {
18748   unsigned int jresult ;
18749   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18750   bool result;
18751
18752   arg1 = (Dali::BaseHandle *)jarg1;
18753   {
18754     try {
18755       result = (bool)Dali_BaseHandle_HasBody((Dali::BaseHandle const *)arg1);
18756     } catch (std::out_of_range& e) {
18757       {
18758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18759       };
18760     } catch (std::exception& e) {
18761       {
18762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18763       };
18764     } catch (Dali::DaliException e) {
18765       {
18766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18767       };
18768     } catch (...) {
18769       {
18770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18771       };
18772     }
18773   }
18774
18775   jresult = result;
18776   return jresult;
18777 }
18778
18779
18780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_BaseHandle_IsEqual(void * jarg1, void * jarg2) {
18781   unsigned int jresult ;
18782   Dali::BaseHandle *arg1 = (Dali::BaseHandle *) 0 ;
18783   Dali::BaseHandle *arg2 = 0 ;
18784   bool result;
18785
18786   arg1 = (Dali::BaseHandle *)jarg1;
18787   arg2 = (Dali::BaseHandle *)jarg2;
18788   if (!arg2) {
18789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18790     return 0;
18791   }
18792   {
18793     try {
18794       result = (bool)Dali_BaseHandle_IsEqual((Dali::BaseHandle const *)arg1,(Dali::BaseHandle const &)*arg2);
18795     } catch (std::out_of_range& e) {
18796       {
18797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18798       };
18799     } catch (std::exception& e) {
18800       {
18801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18802       };
18803     } catch (Dali::DaliException e) {
18804       {
18805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18806       };
18807     } catch (...) {
18808       {
18809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18810       };
18811     }
18812   }
18813
18814   jresult = result;
18815   return jresult;
18816 }
18817
18818
18819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LessThan__SWIG_3(void * jarg1, void * jarg2) {
18820   unsigned int jresult ;
18821   Dali::BaseHandle *arg1 = 0 ;
18822   Dali::BaseHandle *arg2 = 0 ;
18823   bool result;
18824
18825   arg1 = (Dali::BaseHandle *)jarg1;
18826   if (!arg1) {
18827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18828     return 0;
18829   }
18830   arg2 = (Dali::BaseHandle *)jarg2;
18831   if (!arg2) {
18832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::BaseHandle const & type is null", 0);
18833     return 0;
18834   }
18835   {
18836     try {
18837       result = (bool)Dali::operator <((Dali::BaseHandle const &)*arg1,(Dali::BaseHandle const &)*arg2);
18838     } catch (std::out_of_range& e) {
18839       {
18840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
18841       };
18842     } catch (std::exception& e) {
18843       {
18844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
18845       };
18846     } catch (Dali::DaliException e) {
18847       {
18848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
18849       };
18850     } catch (...) {
18851       {
18852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
18853       };
18854     }
18855   }
18856
18857   jresult = result;
18858   return jresult;
18859 }
18860
18861
18862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTrackerInterface(void * jarg1) {
18863   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18864
18865   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18866   {
18867     try {
18868       delete arg1;
18869     } catch (std::out_of_range& e) {
18870       {
18871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18872       };
18873     } catch (std::exception& e) {
18874       {
18875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18876       };
18877     } catch (Dali::DaliException e) {
18878       {
18879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18880       };
18881     } catch (...) {
18882       {
18883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18884       };
18885     }
18886   }
18887
18888 }
18889
18890
18891 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
18892   Dali::ConnectionTrackerInterface *arg1 = (Dali::ConnectionTrackerInterface *) 0 ;
18893   SlotObserver *arg2 = (SlotObserver *) 0 ;
18894   CallbackBase *arg3 = (CallbackBase *) 0 ;
18895
18896   arg1 = (Dali::ConnectionTrackerInterface *)jarg1;
18897   arg2 = (SlotObserver *)jarg2;
18898   arg3 = (CallbackBase *)jarg3;
18899   {
18900     try {
18901       (arg1)->SignalConnected(arg2,arg3);
18902     } catch (std::out_of_range& e) {
18903       {
18904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18905       };
18906     } catch (std::exception& e) {
18907       {
18908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18909       };
18910     } catch (Dali::DaliException e) {
18911       {
18912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18913       };
18914     } catch (...) {
18915       {
18916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18917       };
18918     }
18919   }
18920
18921 }
18922
18923
18924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalObserver(void * jarg1) {
18925   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18926
18927   arg1 = (Dali::SignalObserver *)jarg1;
18928   {
18929     try {
18930       delete arg1;
18931     } catch (std::out_of_range& e) {
18932       {
18933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18934       };
18935     } catch (std::exception& e) {
18936       {
18937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18938       };
18939     } catch (Dali::DaliException e) {
18940       {
18941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18942       };
18943     } catch (...) {
18944       {
18945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18946       };
18947     }
18948   }
18949
18950 }
18951
18952
18953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SignalObserver_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
18954   Dali::SignalObserver *arg1 = (Dali::SignalObserver *) 0 ;
18955   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
18956   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
18957
18958   arg1 = (Dali::SignalObserver *)jarg1;
18959   arg2 = (Dali::SlotObserver *)jarg2;
18960   arg3 = (Dali::CallbackBase *)jarg3;
18961   {
18962     try {
18963       (arg1)->SignalDisconnected(arg2,arg3);
18964     } catch (std::out_of_range& e) {
18965       {
18966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18967       };
18968     } catch (std::exception& e) {
18969       {
18970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
18971       };
18972     } catch (Dali::DaliException e) {
18973       {
18974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
18975       };
18976     } catch (...) {
18977       {
18978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
18979       };
18980     }
18981   }
18982
18983 }
18984
18985
18986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SlotObserver(void * jarg1) {
18987   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
18988
18989   arg1 = (Dali::SlotObserver *)jarg1;
18990   {
18991     try {
18992       delete arg1;
18993     } catch (std::out_of_range& e) {
18994       {
18995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
18996       };
18997     } catch (std::exception& e) {
18998       {
18999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19000       };
19001     } catch (Dali::DaliException e) {
19002       {
19003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19004       };
19005     } catch (...) {
19006       {
19007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19008       };
19009     }
19010   }
19011
19012 }
19013
19014
19015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SlotObserver_SlotDisconnected(void * jarg1, void * jarg2) {
19016   Dali::SlotObserver *arg1 = (Dali::SlotObserver *) 0 ;
19017   Dali::CallbackBase *arg2 = (Dali::CallbackBase *) 0 ;
19018
19019   arg1 = (Dali::SlotObserver *)jarg1;
19020   arg2 = (Dali::CallbackBase *)jarg2;
19021   {
19022     try {
19023       (arg1)->SlotDisconnected(arg2);
19024     } catch (std::out_of_range& e) {
19025       {
19026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19027       };
19028     } catch (std::exception& e) {
19029       {
19030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19031       };
19032     } catch (Dali::DaliException e) {
19033       {
19034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19035       };
19036     } catch (...) {
19037       {
19038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19039       };
19040     }
19041   }
19042
19043 }
19044
19045
19046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ConnectionTracker(void * jarg1) {
19047   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19048
19049   arg1 = (Dali::ConnectionTracker *)jarg1;
19050   {
19051     try {
19052       delete arg1;
19053     } catch (std::out_of_range& e) {
19054       {
19055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19056       };
19057     } catch (std::exception& e) {
19058       {
19059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19060       };
19061     } catch (Dali::DaliException e) {
19062       {
19063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19064       };
19065     } catch (...) {
19066       {
19067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19068       };
19069     }
19070   }
19071
19072 }
19073
19074
19075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_DisconnectAll(void * jarg1) {
19076   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19077
19078   arg1 = (Dali::ConnectionTracker *)jarg1;
19079   {
19080     try {
19081       (arg1)->DisconnectAll();
19082     } catch (std::out_of_range& e) {
19083       {
19084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19085       };
19086     } catch (std::exception& e) {
19087       {
19088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19089       };
19090     } catch (Dali::DaliException e) {
19091       {
19092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19093       };
19094     } catch (...) {
19095       {
19096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19097       };
19098     }
19099   }
19100
19101 }
19102
19103
19104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
19105   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19106   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19107   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19108
19109   arg1 = (Dali::ConnectionTracker *)jarg1;
19110   arg2 = (Dali::SlotObserver *)jarg2;
19111   arg3 = (Dali::CallbackBase *)jarg3;
19112   {
19113     try {
19114       (arg1)->SignalConnected(arg2,arg3);
19115     } catch (std::out_of_range& e) {
19116       {
19117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19118       };
19119     } catch (std::exception& e) {
19120       {
19121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19122       };
19123     } catch (Dali::DaliException e) {
19124       {
19125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19126       };
19127     } catch (...) {
19128       {
19129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19130       };
19131     }
19132   }
19133
19134 }
19135
19136
19137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ConnectionTracker_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
19138   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19139   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
19140   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
19141
19142   arg1 = (Dali::ConnectionTracker *)jarg1;
19143   arg2 = (Dali::SlotObserver *)jarg2;
19144   arg3 = (Dali::CallbackBase *)jarg3;
19145   {
19146     try {
19147       (arg1)->SignalDisconnected(arg2,arg3);
19148     } catch (std::out_of_range& e) {
19149       {
19150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19151       };
19152     } catch (std::exception& e) {
19153       {
19154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19155       };
19156     } catch (Dali::DaliException e) {
19157       {
19158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19159       };
19160     } catch (...) {
19161       {
19162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19163       };
19164     }
19165   }
19166
19167 }
19168
19169
19170 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ConnectionTracker_GetConnectionCount(void * jarg1) {
19171   unsigned long jresult ;
19172   Dali::ConnectionTracker *arg1 = (Dali::ConnectionTracker *) 0 ;
19173   std::size_t result;
19174
19175   arg1 = (Dali::ConnectionTracker *)jarg1;
19176   {
19177     try {
19178       result = ((Dali::ConnectionTracker const *)arg1)->GetConnectionCount();
19179     } catch (std::out_of_range& e) {
19180       {
19181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19182       };
19183     } catch (std::exception& e) {
19184       {
19185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19186       };
19187     } catch (Dali::DaliException e) {
19188       {
19189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19190       };
19191     } catch (...) {
19192       {
19193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19194       };
19195     }
19196   }
19197
19198   jresult = (unsigned long)result;
19199   return jresult;
19200 }
19201
19202
19203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_0() {
19204   void * jresult ;
19205   Dali::ObjectRegistry *result = 0 ;
19206
19207   {
19208     try {
19209       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry();
19210     } catch (std::out_of_range& e) {
19211       {
19212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19213       };
19214     } catch (std::exception& e) {
19215       {
19216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19217       };
19218     } catch (Dali::DaliException e) {
19219       {
19220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19221       };
19222     } catch (...) {
19223       {
19224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19225       };
19226     }
19227   }
19228
19229   jresult = (void *)result;
19230   return jresult;
19231 }
19232
19233
19234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectRegistry(void * jarg1) {
19235   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19236
19237   arg1 = (Dali::ObjectRegistry *)jarg1;
19238   {
19239     try {
19240       delete arg1;
19241     } catch (std::out_of_range& e) {
19242       {
19243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19244       };
19245     } catch (std::exception& e) {
19246       {
19247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19248       };
19249     } catch (Dali::DaliException e) {
19250       {
19251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19252       };
19253     } catch (...) {
19254       {
19255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19256       };
19257     }
19258   }
19259
19260 }
19261
19262
19263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectRegistry__SWIG_1(void * jarg1) {
19264   void * jresult ;
19265   Dali::ObjectRegistry *arg1 = 0 ;
19266   Dali::ObjectRegistry *result = 0 ;
19267
19268   arg1 = (Dali::ObjectRegistry *)jarg1;
19269   if (!arg1) {
19270     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19271     return 0;
19272   }
19273   {
19274     try {
19275       result = (Dali::ObjectRegistry *)new Dali::ObjectRegistry((Dali::ObjectRegistry const &)*arg1);
19276     } catch (std::out_of_range& e) {
19277       {
19278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19279       };
19280     } catch (std::exception& e) {
19281       {
19282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19283       };
19284     } catch (Dali::DaliException e) {
19285       {
19286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19287       };
19288     } catch (...) {
19289       {
19290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19291       };
19292     }
19293   }
19294
19295   jresult = (void *)result;
19296   return jresult;
19297 }
19298
19299
19300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_Assign(void * jarg1, void * jarg2) {
19301   void * jresult ;
19302   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19303   Dali::ObjectRegistry *arg2 = 0 ;
19304   Dali::ObjectRegistry *result = 0 ;
19305
19306   arg1 = (Dali::ObjectRegistry *)jarg1;
19307   arg2 = (Dali::ObjectRegistry *)jarg2;
19308   if (!arg2) {
19309     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::ObjectRegistry const & type is null", 0);
19310     return 0;
19311   }
19312   {
19313     try {
19314       result = (Dali::ObjectRegistry *) &(arg1)->operator =((Dali::ObjectRegistry const &)*arg2);
19315     } catch (std::out_of_range& e) {
19316       {
19317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19318       };
19319     } catch (std::exception& e) {
19320       {
19321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19322       };
19323     } catch (Dali::DaliException e) {
19324       {
19325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19326       };
19327     } catch (...) {
19328       {
19329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19330       };
19331     }
19332   }
19333
19334   jresult = (void *)result;
19335   return jresult;
19336 }
19337
19338
19339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectCreatedSignal(void * jarg1) {
19340   void * jresult ;
19341   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19342   Dali::ObjectRegistry::ObjectCreatedSignalType *result = 0 ;
19343
19344   arg1 = (Dali::ObjectRegistry *)jarg1;
19345   {
19346     try {
19347       result = (Dali::ObjectRegistry::ObjectCreatedSignalType *) &(arg1)->ObjectCreatedSignal();
19348     } catch (std::out_of_range& e) {
19349       {
19350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19351       };
19352     } catch (std::exception& e) {
19353       {
19354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19355       };
19356     } catch (Dali::DaliException e) {
19357       {
19358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19359       };
19360     } catch (...) {
19361       {
19362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19363       };
19364     }
19365   }
19366
19367   jresult = (void *)result;
19368   return jresult;
19369 }
19370
19371
19372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ObjectRegistry_ObjectDestroyedSignal(void * jarg1) {
19373   void * jresult ;
19374   Dali::ObjectRegistry *arg1 = (Dali::ObjectRegistry *) 0 ;
19375   Dali::ObjectRegistry::ObjectDestroyedSignalType *result = 0 ;
19376
19377   arg1 = (Dali::ObjectRegistry *)jarg1;
19378   {
19379     try {
19380       result = (Dali::ObjectRegistry::ObjectDestroyedSignalType *) &(arg1)->ObjectDestroyedSignal();
19381     } catch (std::out_of_range& e) {
19382       {
19383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19384       };
19385     } catch (std::exception& e) {
19386       {
19387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19388       };
19389     } catch (Dali::DaliException e) {
19390       {
19391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19392       };
19393     } catch (...) {
19394       {
19395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19396       };
19397     }
19398   }
19399
19400   jresult = (void *)result;
19401   return jresult;
19402 }
19403
19404
19405 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_0() {
19406   void * jresult ;
19407   Dali::PropertyCondition *result = 0 ;
19408
19409   {
19410     try {
19411       result = (Dali::PropertyCondition *)new Dali::PropertyCondition();
19412     } catch (std::out_of_range& e) {
19413       {
19414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19415       };
19416     } catch (std::exception& e) {
19417       {
19418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19419       };
19420     } catch (Dali::DaliException e) {
19421       {
19422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19423       };
19424     } catch (...) {
19425       {
19426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19427       };
19428     }
19429   }
19430
19431   jresult = (void *)result;
19432   return jresult;
19433 }
19434
19435
19436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyCondition(void * jarg1) {
19437   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19438
19439   arg1 = (Dali::PropertyCondition *)jarg1;
19440   {
19441     try {
19442       delete arg1;
19443     } catch (std::out_of_range& e) {
19444       {
19445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19446       };
19447     } catch (std::exception& e) {
19448       {
19449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19450       };
19451     } catch (Dali::DaliException e) {
19452       {
19453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19454       };
19455     } catch (...) {
19456       {
19457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19458       };
19459     }
19460   }
19461
19462 }
19463
19464
19465 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyCondition__SWIG_1(void * jarg1) {
19466   void * jresult ;
19467   Dali::PropertyCondition *arg1 = 0 ;
19468   Dali::PropertyCondition *result = 0 ;
19469
19470   arg1 = (Dali::PropertyCondition *)jarg1;
19471   if (!arg1) {
19472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19473     return 0;
19474   }
19475   {
19476     try {
19477       result = (Dali::PropertyCondition *)new Dali::PropertyCondition((Dali::PropertyCondition const &)*arg1);
19478     } catch (std::out_of_range& e) {
19479       {
19480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19481       };
19482     } catch (std::exception& e) {
19483       {
19484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19485       };
19486     } catch (Dali::DaliException e) {
19487       {
19488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19489       };
19490     } catch (...) {
19491       {
19492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19493       };
19494     }
19495   }
19496
19497   jresult = (void *)result;
19498   return jresult;
19499 }
19500
19501
19502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyCondition_Assign(void * jarg1, void * jarg2) {
19503   void * jresult ;
19504   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19505   Dali::PropertyCondition *arg2 = 0 ;
19506   Dali::PropertyCondition *result = 0 ;
19507
19508   arg1 = (Dali::PropertyCondition *)jarg1;
19509   arg2 = (Dali::PropertyCondition *)jarg2;
19510   if (!arg2) {
19511     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
19512     return 0;
19513   }
19514   {
19515     try {
19516       result = (Dali::PropertyCondition *) &(arg1)->operator =((Dali::PropertyCondition const &)*arg2);
19517     } catch (std::out_of_range& e) {
19518       {
19519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19520       };
19521     } catch (std::exception& e) {
19522       {
19523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19524       };
19525     } catch (Dali::DaliException e) {
19526       {
19527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19528       };
19529     } catch (...) {
19530       {
19531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19532       };
19533     }
19534   }
19535
19536   jresult = (void *)result;
19537   return jresult;
19538 }
19539
19540
19541 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgumentCount(void * jarg1) {
19542   unsigned long jresult ;
19543   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19544   std::size_t result;
19545
19546   arg1 = (Dali::PropertyCondition *)jarg1;
19547   {
19548     try {
19549       result = ((Dali::PropertyCondition const *)arg1)->GetArgumentCount();
19550     } catch (std::out_of_range& e) {
19551       {
19552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19553       };
19554     } catch (std::exception& e) {
19555       {
19556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19557       };
19558     } catch (...) {
19559       {
19560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19561       };
19562     }
19563   }
19564   jresult = (unsigned long)result;
19565   return jresult;
19566 }
19567
19568
19569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PropertyCondition_GetArgument(void * jarg1, unsigned long jarg2) {
19570   float jresult ;
19571   Dali::PropertyCondition *arg1 = (Dali::PropertyCondition *) 0 ;
19572   std::size_t arg2 ;
19573   float result;
19574
19575   arg1 = (Dali::PropertyCondition *)jarg1;
19576   arg2 = (std::size_t)jarg2;
19577   {
19578     try {
19579       result = (float)((Dali::PropertyCondition const *)arg1)->GetArgument(arg2);
19580     } catch (std::out_of_range& e) {
19581       {
19582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19583       };
19584     } catch (std::exception& e) {
19585       {
19586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19587       };
19588     } catch (...) {
19589       {
19590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19591       };
19592     }
19593   }
19594   jresult = result;
19595   return jresult;
19596 }
19597
19598
19599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LessThanCondition(float jarg1) {
19600   void * jresult ;
19601   float arg1 ;
19602   Dali::PropertyCondition result;
19603
19604   arg1 = (float)jarg1;
19605   {
19606     try {
19607       result = Dali::LessThanCondition(arg1);
19608     } catch (std::out_of_range& e) {
19609       {
19610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19611       };
19612     } catch (std::exception& e) {
19613       {
19614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19615       };
19616     } catch (Dali::DaliException e) {
19617       {
19618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19619       };
19620     } catch (...) {
19621       {
19622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19623       };
19624     }
19625   }
19626
19627   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19628   return jresult;
19629 }
19630
19631
19632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GreaterThanCondition(float jarg1) {
19633   void * jresult ;
19634   float arg1 ;
19635   Dali::PropertyCondition result;
19636
19637   arg1 = (float)jarg1;
19638   {
19639     try {
19640       result = Dali::GreaterThanCondition(arg1);
19641     } catch (std::out_of_range& e) {
19642       {
19643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19644       };
19645     } catch (std::exception& e) {
19646       {
19647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19648       };
19649     } catch (Dali::DaliException e) {
19650       {
19651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19652       };
19653     } catch (...) {
19654       {
19655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19656       };
19657     }
19658   }
19659
19660   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19661   return jresult;
19662 }
19663
19664
19665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_InsideCondition(float jarg1, float jarg2) {
19666   void * jresult ;
19667   float arg1 ;
19668   float arg2 ;
19669   Dali::PropertyCondition result;
19670
19671   arg1 = (float)jarg1;
19672   arg2 = (float)jarg2;
19673   {
19674     try {
19675       result = Dali::InsideCondition(arg1,arg2);
19676     } catch (std::out_of_range& e) {
19677       {
19678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19679       };
19680     } catch (std::exception& e) {
19681       {
19682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19683       };
19684     } catch (Dali::DaliException e) {
19685       {
19686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19687       };
19688     } catch (...) {
19689       {
19690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19691       };
19692     }
19693   }
19694
19695   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19696   return jresult;
19697 }
19698
19699
19700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_OutsideCondition(float jarg1, float jarg2) {
19701   void * jresult ;
19702   float arg1 ;
19703   float arg2 ;
19704   Dali::PropertyCondition result;
19705
19706   arg1 = (float)jarg1;
19707   arg2 = (float)jarg2;
19708   {
19709     try {
19710       result = Dali::OutsideCondition(arg1,arg2);
19711     } catch (std::out_of_range& e) {
19712       {
19713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19714       };
19715     } catch (std::exception& e) {
19716       {
19717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19718       };
19719     } catch (Dali::DaliException e) {
19720       {
19721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19722       };
19723     } catch (...) {
19724       {
19725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19726       };
19727     }
19728   }
19729
19730   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19731   return jresult;
19732 }
19733
19734
19735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_0(float jarg1, float jarg2) {
19736   void * jresult ;
19737   float arg1 ;
19738   float arg2 ;
19739   Dali::PropertyCondition result;
19740
19741   arg1 = (float)jarg1;
19742   arg2 = (float)jarg2;
19743   {
19744     try {
19745       result = Dali::StepCondition(arg1,arg2);
19746     } catch (std::out_of_range& e) {
19747       {
19748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19749       };
19750     } catch (std::exception& e) {
19751       {
19752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19753       };
19754     } catch (Dali::DaliException e) {
19755       {
19756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19757       };
19758     } catch (...) {
19759       {
19760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19761       };
19762     }
19763   }
19764
19765   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19766   return jresult;
19767 }
19768
19769
19770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StepCondition__SWIG_1(float jarg1) {
19771   void * jresult ;
19772   float arg1 ;
19773   Dali::PropertyCondition result;
19774
19775   arg1 = (float)jarg1;
19776   {
19777     try {
19778       result = Dali::StepCondition(arg1);
19779     } catch (std::out_of_range& e) {
19780       {
19781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19782       };
19783     } catch (std::exception& e) {
19784       {
19785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19786       };
19787     } catch (Dali::DaliException e) {
19788       {
19789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19790       };
19791     } catch (...) {
19792       {
19793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19794       };
19795     }
19796   }
19797
19798   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19799   return jresult;
19800 }
19801
19802
19803 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VariableStepCondition(void * jarg1) {
19804   void * jresult ;
19805   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg1 = 0 ;
19806   Dali::PropertyCondition result;
19807
19808   arg1 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg1;
19809   if (!arg1) {
19810     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
19811     return 0;
19812   }
19813   {
19814     try {
19815       result = Dali::VariableStepCondition((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg1);
19816     } catch (std::out_of_range& e) {
19817       {
19818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19819       };
19820     } catch (std::exception& e) {
19821       {
19822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19823       };
19824     } catch (Dali::DaliException e) {
19825       {
19826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19827       };
19828     } catch (...) {
19829       {
19830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19831       };
19832     }
19833   }
19834
19835   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
19836   return jresult;
19837 }
19838
19839
19840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_0() {
19841   void * jresult ;
19842   Dali::PropertyNotification *result = 0 ;
19843
19844   {
19845     try {
19846       result = (Dali::PropertyNotification *)new Dali::PropertyNotification();
19847     } catch (std::out_of_range& e) {
19848       {
19849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19850       };
19851     } catch (std::exception& e) {
19852       {
19853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19854       };
19855     } catch (Dali::DaliException e) {
19856       {
19857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19858       };
19859     } catch (...) {
19860       {
19861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19862       };
19863     }
19864   }
19865
19866   jresult = (void *)result;
19867   return jresult;
19868 }
19869
19870
19871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_DownCast(void * jarg1) {
19872   void * jresult ;
19873   Dali::BaseHandle arg1 ;
19874   Dali::BaseHandle *argp1 ;
19875   Dali::PropertyNotification result;
19876
19877   argp1 = (Dali::BaseHandle *)jarg1;
19878   if (!argp1) {
19879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
19880     return 0;
19881   }
19882   arg1 = *argp1;
19883   {
19884     try {
19885       result = Dali::PropertyNotification::DownCast(arg1);
19886     } catch (std::out_of_range& e) {
19887       {
19888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19889       };
19890     } catch (std::exception& e) {
19891       {
19892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19893       };
19894     } catch (Dali::DaliException e) {
19895       {
19896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19897       };
19898     } catch (...) {
19899       {
19900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19901       };
19902     }
19903   }
19904
19905   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
19906   return jresult;
19907 }
19908
19909
19910 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotification(void * jarg1) {
19911   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19912
19913   arg1 = (Dali::PropertyNotification *)jarg1;
19914   {
19915     try {
19916       delete arg1;
19917     } catch (std::out_of_range& e) {
19918       {
19919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
19920       };
19921     } catch (std::exception& e) {
19922       {
19923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
19924       };
19925     } catch (Dali::DaliException e) {
19926       {
19927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
19928       };
19929     } catch (...) {
19930       {
19931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
19932       };
19933     }
19934   }
19935
19936 }
19937
19938
19939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotification__SWIG_1(void * jarg1) {
19940   void * jresult ;
19941   Dali::PropertyNotification *arg1 = 0 ;
19942   Dali::PropertyNotification *result = 0 ;
19943
19944   arg1 = (Dali::PropertyNotification *)jarg1;
19945   if (!arg1) {
19946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19947     return 0;
19948   }
19949   {
19950     try {
19951       result = (Dali::PropertyNotification *)new Dali::PropertyNotification((Dali::PropertyNotification const &)*arg1);
19952     } catch (std::out_of_range& e) {
19953       {
19954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19955       };
19956     } catch (std::exception& e) {
19957       {
19958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19959       };
19960     } catch (Dali::DaliException e) {
19961       {
19962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
19963       };
19964     } catch (...) {
19965       {
19966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
19967       };
19968     }
19969   }
19970
19971   jresult = (void *)result;
19972   return jresult;
19973 }
19974
19975
19976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_Assign(void * jarg1, void * jarg2) {
19977   void * jresult ;
19978   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
19979   Dali::PropertyNotification *arg2 = 0 ;
19980   Dali::PropertyNotification *result = 0 ;
19981
19982   arg1 = (Dali::PropertyNotification *)jarg1;
19983   arg2 = (Dali::PropertyNotification *)jarg2;
19984   if (!arg2) {
19985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification const & type is null", 0);
19986     return 0;
19987   }
19988   {
19989     try {
19990       result = (Dali::PropertyNotification *) &(arg1)->operator =((Dali::PropertyNotification const &)*arg2);
19991     } catch (std::out_of_range& e) {
19992       {
19993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
19994       };
19995     } catch (std::exception& e) {
19996       {
19997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
19998       };
19999     } catch (Dali::DaliException e) {
20000       {
20001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20002       };
20003     } catch (...) {
20004       {
20005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20006       };
20007     }
20008   }
20009
20010   jresult = (void *)result;
20011   return jresult;
20012 }
20013
20014
20015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetCondition__SWIG_0(void * jarg1) {
20016   void * jresult ;
20017   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20018   Dali::PropertyCondition result;
20019
20020   arg1 = (Dali::PropertyNotification *)jarg1;
20021   {
20022     try {
20023       result = (arg1)->GetCondition();
20024     } catch (std::out_of_range& e) {
20025       {
20026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20027       };
20028     } catch (std::exception& e) {
20029       {
20030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20031       };
20032     } catch (Dali::DaliException e) {
20033       {
20034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20035       };
20036     } catch (...) {
20037       {
20038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20039       };
20040     }
20041   }
20042
20043   jresult = new Dali::PropertyCondition((const Dali::PropertyCondition &)result);
20044   return jresult;
20045 }
20046
20047
20048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTarget(void * jarg1) {
20049   void * jresult ;
20050   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20051   Dali::Handle result;
20052
20053   arg1 = (Dali::PropertyNotification *)jarg1;
20054   {
20055     try {
20056       result = ((Dali::PropertyNotification const *)arg1)->GetTarget();
20057     } catch (std::out_of_range& e) {
20058       {
20059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20060       };
20061     } catch (std::exception& e) {
20062       {
20063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20064       };
20065     } catch (Dali::DaliException e) {
20066       {
20067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20068       };
20069     } catch (...) {
20070       {
20071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20072       };
20073     }
20074   }
20075
20076   jresult = new Dali::Handle((const Dali::Handle &)result);
20077   return jresult;
20078 }
20079
20080
20081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetTargetProperty(void * jarg1) {
20082   int jresult ;
20083   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20084   Dali::Property::Index result;
20085
20086   arg1 = (Dali::PropertyNotification *)jarg1;
20087   {
20088     try {
20089       result = (Dali::Property::Index)((Dali::PropertyNotification const *)arg1)->GetTargetProperty();
20090     } catch (std::out_of_range& e) {
20091       {
20092         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20093       };
20094     } catch (std::exception& e) {
20095       {
20096         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20097       };
20098     } catch (Dali::DaliException e) {
20099       {
20100         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20101       };
20102     } catch (...) {
20103       {
20104         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20105       };
20106     }
20107   }
20108
20109   jresult = result;
20110   return jresult;
20111 }
20112
20113
20114 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotification_SetNotifyMode(void * jarg1, int jarg2) {
20115   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20116   Dali::PropertyNotification::NotifyMode arg2 ;
20117
20118   arg1 = (Dali::PropertyNotification *)jarg1;
20119   arg2 = (Dali::PropertyNotification::NotifyMode)jarg2;
20120   {
20121     try {
20122       (arg1)->SetNotifyMode(arg2);
20123     } catch (std::out_of_range& e) {
20124       {
20125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20126       };
20127     } catch (std::exception& e) {
20128       {
20129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20130       };
20131     } catch (Dali::DaliException e) {
20132       {
20133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20134       };
20135     } catch (...) {
20136       {
20137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20138       };
20139     }
20140   }
20141
20142 }
20143
20144
20145 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyMode(void * jarg1) {
20146   int jresult ;
20147   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20148   Dali::PropertyNotification::NotifyMode result;
20149
20150   arg1 = (Dali::PropertyNotification *)jarg1;
20151   {
20152     try {
20153       result = (Dali::PropertyNotification::NotifyMode)(arg1)->GetNotifyMode();
20154     } catch (std::out_of_range& e) {
20155       {
20156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20157       };
20158     } catch (std::exception& e) {
20159       {
20160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20161       };
20162     } catch (Dali::DaliException e) {
20163       {
20164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20165       };
20166     } catch (...) {
20167       {
20168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20169       };
20170     }
20171   }
20172
20173   jresult = (int)result;
20174   return jresult;
20175 }
20176
20177
20178 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotification_GetNotifyResult(void * jarg1) {
20179   unsigned int jresult ;
20180   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20181   bool result;
20182
20183   arg1 = (Dali::PropertyNotification *)jarg1;
20184   {
20185     try {
20186       result = (bool)((Dali::PropertyNotification const *)arg1)->GetNotifyResult();
20187     } catch (std::out_of_range& e) {
20188       {
20189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20190       };
20191     } catch (std::exception& e) {
20192       {
20193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20194       };
20195     } catch (Dali::DaliException e) {
20196       {
20197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20198       };
20199     } catch (...) {
20200       {
20201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20202       };
20203     }
20204   }
20205
20206   jresult = result;
20207   return jresult;
20208 }
20209
20210
20211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyNotification_NotifySignal(void * jarg1) {
20212   void * jresult ;
20213   Dali::PropertyNotification *arg1 = (Dali::PropertyNotification *) 0 ;
20214   Dali::PropertyNotifySignalType *result = 0 ;
20215
20216   arg1 = (Dali::PropertyNotification *)jarg1;
20217   {
20218     try {
20219       result = (Dali::PropertyNotifySignalType *) &(arg1)->NotifySignal();
20220     } catch (std::out_of_range& e) {
20221       {
20222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20223       };
20224     } catch (std::exception& e) {
20225       {
20226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20227       };
20228     } catch (Dali::DaliException e) {
20229       {
20230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20231       };
20232     } catch (...) {
20233       {
20234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20235       };
20236     }
20237   }
20238
20239   jresult = (void *)result;
20240   return jresult;
20241 }
20242
20243
20244 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_0() {
20245   void * jresult ;
20246   Dali::Handle *result = 0 ;
20247
20248   {
20249     try {
20250       result = (Dali::Handle *)new Dali::Handle();
20251     } catch (std::out_of_range& e) {
20252       {
20253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20254       };
20255     } catch (std::exception& e) {
20256       {
20257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20258       };
20259     } catch (Dali::DaliException e) {
20260       {
20261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20262       };
20263     } catch (...) {
20264       {
20265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20266       };
20267     }
20268   }
20269
20270   jresult = (void *)result;
20271   return jresult;
20272 }
20273
20274
20275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_New() {
20276   void * jresult ;
20277   Dali::Handle result;
20278
20279   {
20280     try {
20281       result = Dali::Handle::New();
20282     } catch (std::out_of_range& e) {
20283       {
20284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20285       };
20286     } catch (std::exception& e) {
20287       {
20288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20289       };
20290     } catch (Dali::DaliException e) {
20291       {
20292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20293       };
20294     } catch (...) {
20295       {
20296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20297       };
20298     }
20299   }
20300
20301   jresult = new Dali::Handle((const Dali::Handle &)result);
20302   return jresult;
20303 }
20304
20305
20306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Handle(void * jarg1) {
20307   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20308
20309   arg1 = (Dali::Handle *)jarg1;
20310   {
20311     try {
20312       delete arg1;
20313     } catch (std::out_of_range& e) {
20314       {
20315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20316       };
20317     } catch (std::exception& e) {
20318       {
20319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20320       };
20321     } catch (Dali::DaliException e) {
20322       {
20323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20324       };
20325     } catch (...) {
20326       {
20327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20328       };
20329     }
20330   }
20331
20332 }
20333
20334
20335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Handle__SWIG_1(void * jarg1) {
20336   void * jresult ;
20337   Dali::Handle *arg1 = 0 ;
20338   Dali::Handle *result = 0 ;
20339
20340   arg1 = (Dali::Handle *)jarg1;
20341   if (!arg1) {
20342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20343     return 0;
20344   }
20345   {
20346     try {
20347       result = (Dali::Handle *)new Dali::Handle((Dali::Handle const &)*arg1);
20348     } catch (std::out_of_range& e) {
20349       {
20350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20351       };
20352     } catch (std::exception& e) {
20353       {
20354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20355       };
20356     } catch (Dali::DaliException e) {
20357       {
20358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20359       };
20360     } catch (...) {
20361       {
20362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20363       };
20364     }
20365   }
20366
20367   jresult = (void *)result;
20368   return jresult;
20369 }
20370
20371
20372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_Assign(void * jarg1, void * jarg2) {
20373   void * jresult ;
20374   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20375   Dali::Handle *arg2 = 0 ;
20376   Dali::Handle *result = 0 ;
20377
20378   arg1 = (Dali::Handle *)jarg1;
20379   arg2 = (Dali::Handle *)jarg2;
20380   if (!arg2) {
20381     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle const & type is null", 0);
20382     return 0;
20383   }
20384   {
20385     try {
20386       result = (Dali::Handle *) &(arg1)->operator =((Dali::Handle const &)*arg2);
20387     } catch (std::out_of_range& e) {
20388       {
20389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20390       };
20391     } catch (std::exception& e) {
20392       {
20393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20394       };
20395     } catch (Dali::DaliException e) {
20396       {
20397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20398       };
20399     } catch (...) {
20400       {
20401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20402       };
20403     }
20404   }
20405
20406   jresult = (void *)result;
20407   return jresult;
20408 }
20409
20410
20411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_DownCast(void * jarg1) {
20412   void * jresult ;
20413   Dali::BaseHandle arg1 ;
20414   Dali::BaseHandle *argp1 ;
20415   Dali::Handle result;
20416
20417   argp1 = (Dali::BaseHandle *)jarg1;
20418   if (!argp1) {
20419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
20420     return 0;
20421   }
20422   arg1 = *argp1;
20423   {
20424     try {
20425       result = Dali::Handle::DownCast(arg1);
20426     } catch (std::out_of_range& e) {
20427       {
20428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20429       };
20430     } catch (std::exception& e) {
20431       {
20432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20433       };
20434     } catch (Dali::DaliException e) {
20435       {
20436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20437       };
20438     } catch (...) {
20439       {
20440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20441       };
20442     }
20443   }
20444
20445   jresult = new Dali::Handle((const Dali::Handle &)result);
20446   return jresult;
20447 }
20448
20449
20450 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_Supports(void * jarg1, int jarg2) {
20451   unsigned int jresult ;
20452   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20453   Dali::Handle::Capability arg2 ;
20454   bool result;
20455
20456   arg1 = (Dali::Handle *)jarg1;
20457   arg2 = (Dali::Handle::Capability)jarg2;
20458   {
20459     try {
20460       result = (bool)((Dali::Handle const *)arg1)->Supports(arg2);
20461     } catch (std::out_of_range& e) {
20462       {
20463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20464       };
20465     } catch (std::exception& e) {
20466       {
20467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20468       };
20469     } catch (Dali::DaliException e) {
20470       {
20471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20472       };
20473     } catch (...) {
20474       {
20475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20476       };
20477     }
20478   }
20479
20480   jresult = result;
20481   return jresult;
20482 }
20483
20484
20485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyCount(void * jarg1) {
20486   unsigned int jresult ;
20487   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20488   unsigned int result;
20489
20490   arg1 = (Dali::Handle *)jarg1;
20491   {
20492     try {
20493       result = (unsigned int)((Dali::Handle const *)arg1)->GetPropertyCount();
20494     } catch (std::out_of_range& e) {
20495       {
20496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20497       };
20498     } catch (std::exception& e) {
20499       {
20500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20501       };
20502     } catch (Dali::DaliException e) {
20503       {
20504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20505       };
20506     } catch (...) {
20507       {
20508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20509       };
20510     }
20511   }
20512
20513   jresult = result;
20514   return jresult;
20515 }
20516
20517
20518 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Handle_GetPropertyName(void * jarg1, int jarg2) {
20519   char * jresult ;
20520   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20521   Dali::Property::Index arg2 ;
20522   std::string result;
20523
20524   arg1 = (Dali::Handle *)jarg1;
20525   arg2 = (Dali::Property::Index)jarg2;
20526   {
20527     try {
20528       result = ((Dali::Handle const *)arg1)->GetPropertyName(arg2);
20529     } catch (std::out_of_range& e) {
20530       {
20531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20532       };
20533     } catch (std::exception& e) {
20534       {
20535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20536       };
20537     } catch (Dali::DaliException e) {
20538       {
20539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20540       };
20541     } catch (...) {
20542       {
20543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20544       };
20545     }
20546   }
20547
20548   jresult = SWIG_csharp_string_callback((&result)->c_str());
20549   return jresult;
20550 }
20551
20552
20553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndex(void * jarg1, char * jarg2) {
20554   int jresult ;
20555   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20556   std::string *arg2 = 0 ;
20557   Dali::Property::Index result;
20558
20559   arg1 = (Dali::Handle *)jarg1;
20560   if (!jarg2) {
20561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20562     return 0;
20563   }
20564   std::string arg2_str(jarg2);
20565   arg2 = &arg2_str;
20566   {
20567     try {
20568       result = (Dali::Property::Index)((Dali::Handle const *)arg1)->GetPropertyIndex((std::string const &)*arg2);
20569     } catch (std::out_of_range& e) {
20570       {
20571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20572       };
20573     } catch (std::exception& e) {
20574       {
20575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20576       };
20577     } catch (Dali::DaliException e) {
20578       {
20579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20580       };
20581     } catch (...) {
20582       {
20583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20584       };
20585     }
20586   }
20587
20588   jresult = result;
20589
20590   //argout typemap for const std::string&
20591
20592   return jresult;
20593 }
20594
20595
20596 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyWritable(void * jarg1, int jarg2) {
20597   unsigned int jresult ;
20598   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20599   Dali::Property::Index arg2 ;
20600   bool result;
20601
20602   arg1 = (Dali::Handle *)jarg1;
20603   arg2 = (Dali::Property::Index)jarg2;
20604   {
20605     try {
20606       result = (bool)((Dali::Handle const *)arg1)->IsPropertyWritable(arg2);
20607     } catch (std::out_of_range& e) {
20608       {
20609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20610       };
20611     } catch (std::exception& e) {
20612       {
20613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20614       };
20615     } catch (Dali::DaliException e) {
20616       {
20617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20618       };
20619     } catch (...) {
20620       {
20621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20622       };
20623     }
20624   }
20625
20626   jresult = result;
20627   return jresult;
20628 }
20629
20630
20631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAnimatable(void * jarg1, int jarg2) {
20632   unsigned int jresult ;
20633   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20634   Dali::Property::Index arg2 ;
20635   bool result;
20636
20637   arg1 = (Dali::Handle *)jarg1;
20638   arg2 = (Dali::Property::Index)jarg2;
20639   {
20640     try {
20641       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAnimatable(arg2);
20642     } catch (std::out_of_range& e) {
20643       {
20644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20645       };
20646     } catch (std::exception& e) {
20647       {
20648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20649       };
20650     } catch (Dali::DaliException e) {
20651       {
20652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20653       };
20654     } catch (...) {
20655       {
20656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20657       };
20658     }
20659   }
20660
20661   jresult = result;
20662   return jresult;
20663 }
20664
20665
20666 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Handle_IsPropertyAConstraintInput(void * jarg1, int jarg2) {
20667   unsigned int jresult ;
20668   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20669   Dali::Property::Index arg2 ;
20670   bool result;
20671
20672   arg1 = (Dali::Handle *)jarg1;
20673   arg2 = (Dali::Property::Index)jarg2;
20674   {
20675     try {
20676       result = (bool)((Dali::Handle const *)arg1)->IsPropertyAConstraintInput(arg2);
20677     } catch (std::out_of_range& e) {
20678       {
20679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20680       };
20681     } catch (std::exception& e) {
20682       {
20683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20684       };
20685     } catch (Dali::DaliException e) {
20686       {
20687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20688       };
20689     } catch (...) {
20690       {
20691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20692       };
20693     }
20694   }
20695
20696   jresult = result;
20697   return jresult;
20698 }
20699
20700
20701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_GetPropertyType(void * jarg1, int jarg2) {
20702   int jresult ;
20703   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20704   Dali::Property::Index arg2 ;
20705   Dali::Property::Type result;
20706
20707   arg1 = (Dali::Handle *)jarg1;
20708   arg2 = (Dali::Property::Index)jarg2;
20709   {
20710     try {
20711       result = (Dali::Property::Type)((Dali::Handle const *)arg1)->GetPropertyType(arg2);
20712     } catch (std::out_of_range& e) {
20713       {
20714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20715       };
20716     } catch (std::exception& e) {
20717       {
20718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20719       };
20720     } catch (Dali::DaliException e) {
20721       {
20722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20723       };
20724     } catch (...) {
20725       {
20726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20727       };
20728     }
20729   }
20730
20731   jresult = (int)result;
20732   return jresult;
20733 }
20734
20735
20736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_SetProperty(void * jarg1, int jarg2, void * jarg3) {
20737   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20738   Dali::Property::Index arg2 ;
20739   Dali::Property::Value *arg3 = 0 ;
20740
20741   arg1 = (Dali::Handle *)jarg1;
20742   arg2 = (Dali::Property::Index)jarg2;
20743   arg3 = (Dali::Property::Value *)jarg3;
20744   if (!arg3) {
20745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20746     return ;
20747   }
20748   {
20749     try {
20750       (arg1)->SetProperty(arg2,(Dali::Property::Value const &)*arg3);
20751     } catch (std::out_of_range& e) {
20752       {
20753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20754       };
20755     } catch (std::exception& e) {
20756       {
20757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20758       };
20759     } catch (Dali::DaliException e) {
20760       {
20761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20762       };
20763     } catch (...) {
20764       {
20765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20766       };
20767     }
20768   }
20769
20770 }
20771
20772
20773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_0(void * jarg1, char * jarg2, void * jarg3) {
20774   int jresult ;
20775   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20776   std::string *arg2 = 0 ;
20777   Dali::Property::Value *arg3 = 0 ;
20778   Dali::Property::Index result;
20779
20780   arg1 = (Dali::Handle *)jarg1;
20781   if (!jarg2) {
20782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20783     return 0;
20784   }
20785   std::string arg2_str(jarg2);
20786   arg2 = &arg2_str;
20787   arg3 = (Dali::Property::Value *)jarg3;
20788   if (!arg3) {
20789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20790     return 0;
20791   }
20792   {
20793     try {
20794       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
20795     } catch (std::out_of_range& e) {
20796       {
20797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20798       };
20799     } catch (std::exception& e) {
20800       {
20801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20802       };
20803     } catch (Dali::DaliException e) {
20804       {
20805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20806       };
20807     } catch (...) {
20808       {
20809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20810       };
20811     }
20812   }
20813
20814   jresult = result;
20815
20816   //argout typemap for const std::string&
20817
20818   return jresult;
20819 }
20820
20821
20822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Handle_RegisterProperty__SWIG_1(void * jarg1, char * jarg2, void * jarg3, int jarg4) {
20823   int jresult ;
20824   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20825   std::string *arg2 = 0 ;
20826   Dali::Property::Value *arg3 = 0 ;
20827   Dali::Property::AccessMode arg4 ;
20828   Dali::Property::Index result;
20829
20830   arg1 = (Dali::Handle *)jarg1;
20831   if (!jarg2) {
20832     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
20833     return 0;
20834   }
20835   std::string arg2_str(jarg2);
20836   arg2 = &arg2_str;
20837   arg3 = (Dali::Property::Value *)jarg3;
20838   if (!arg3) {
20839     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
20840     return 0;
20841   }
20842   arg4 = (Dali::Property::AccessMode)jarg4;
20843   {
20844     try {
20845       result = (Dali::Property::Index)(arg1)->RegisterProperty((std::string const &)*arg2,(Dali::Property::Value const &)*arg3,arg4);
20846     } catch (std::out_of_range& e) {
20847       {
20848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20849       };
20850     } catch (std::exception& e) {
20851       {
20852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20853       };
20854     } catch (Dali::DaliException e) {
20855       {
20856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20857       };
20858     } catch (...) {
20859       {
20860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20861       };
20862     }
20863   }
20864
20865   jresult = result;
20866
20867   //argout typemap for const std::string&
20868
20869   return jresult;
20870 }
20871
20872
20873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_GetProperty(void * jarg1, int jarg2) {
20874   void * jresult ;
20875   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20876   Dali::Property::Index arg2 ;
20877   Dali::Property::Value result;
20878
20879   arg1 = (Dali::Handle *)jarg1;
20880   arg2 = (Dali::Property::Index)jarg2;
20881   {
20882     try {
20883       result = ((Dali::Handle const *)arg1)->GetProperty(arg2);
20884     } catch (std::out_of_range& e) {
20885       {
20886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20887       };
20888     } catch (std::exception& e) {
20889       {
20890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20891       };
20892     } catch (Dali::DaliException e) {
20893       {
20894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20895       };
20896     } catch (...) {
20897       {
20898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20899       };
20900     }
20901   }
20902
20903   jresult = new Dali::Property::Value((const Dali::Property::Value &)result);
20904   return jresult;
20905 }
20906
20907
20908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_GetPropertyIndices(void * jarg1, void * jarg2) {
20909   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20910   Dali::Property::IndexContainer *arg2 = 0 ;
20911
20912   arg1 = (Dali::Handle *)jarg1;
20913   arg2 = (Dali::Property::IndexContainer *)jarg2;
20914   if (!arg2) {
20915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
20916     return ;
20917   }
20918   {
20919     try {
20920       ((Dali::Handle const *)arg1)->GetPropertyIndices(*arg2);
20921     } catch (std::out_of_range& e) {
20922       {
20923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
20924       };
20925     } catch (std::exception& e) {
20926       {
20927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
20928       };
20929     } catch (Dali::DaliException e) {
20930       {
20931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
20932       };
20933     } catch (...) {
20934       {
20935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
20936       };
20937     }
20938   }
20939
20940 }
20941
20942
20943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_0(void * jarg1, int jarg2, void * jarg3) {
20944   void * jresult ;
20945   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20946   Dali::Property::Index arg2 ;
20947   Dali::PropertyCondition *arg3 = 0 ;
20948   Dali::PropertyNotification result;
20949
20950   arg1 = (Dali::Handle *)jarg1;
20951   arg2 = (Dali::Property::Index)jarg2;
20952   arg3 = (Dali::PropertyCondition *)jarg3;
20953   if (!arg3) {
20954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20955     return 0;
20956   }
20957   {
20958     try {
20959       result = (arg1)->AddPropertyNotification(arg2,(Dali::PropertyCondition const &)*arg3);
20960     } catch (std::out_of_range& e) {
20961       {
20962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
20963       };
20964     } catch (std::exception& e) {
20965       {
20966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
20967       };
20968     } catch (Dali::DaliException e) {
20969       {
20970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
20971       };
20972     } catch (...) {
20973       {
20974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
20975       };
20976     }
20977   }
20978
20979   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
20980   return jresult;
20981 }
20982
20983
20984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Handle_AddPropertyNotification__SWIG_1(void * jarg1, int jarg2, int jarg3, void * jarg4) {
20985   void * jresult ;
20986   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
20987   Dali::Property::Index arg2 ;
20988   int arg3 ;
20989   Dali::PropertyCondition *arg4 = 0 ;
20990   Dali::PropertyNotification result;
20991
20992   arg1 = (Dali::Handle *)jarg1;
20993   arg2 = (Dali::Property::Index)jarg2;
20994   arg3 = (int)jarg3;
20995   arg4 = (Dali::PropertyCondition *)jarg4;
20996   if (!arg4) {
20997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyCondition const & type is null", 0);
20998     return 0;
20999   }
21000   {
21001     try {
21002       result = (arg1)->AddPropertyNotification(arg2,arg3,(Dali::PropertyCondition const &)*arg4);
21003     } catch (std::out_of_range& e) {
21004       {
21005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21006       };
21007     } catch (std::exception& e) {
21008       {
21009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21010       };
21011     } catch (Dali::DaliException e) {
21012       {
21013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21014       };
21015     } catch (...) {
21016       {
21017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21018       };
21019     }
21020   }
21021
21022   jresult = new Dali::PropertyNotification((const Dali::PropertyNotification &)result);
21023   return jresult;
21024 }
21025
21026
21027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotification(void * jarg1, void * jarg2) {
21028   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21029   Dali::PropertyNotification arg2 ;
21030   Dali::PropertyNotification *argp2 ;
21031
21032   arg1 = (Dali::Handle *)jarg1;
21033   argp2 = (Dali::PropertyNotification *)jarg2;
21034   if (!argp2) {
21035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PropertyNotification", 0);
21036     return ;
21037   }
21038   arg2 = *argp2;
21039   {
21040     try {
21041       (arg1)->RemovePropertyNotification(arg2);
21042     } catch (std::out_of_range& e) {
21043       {
21044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21045       };
21046     } catch (std::exception& e) {
21047       {
21048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21049       };
21050     } catch (Dali::DaliException e) {
21051       {
21052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21053       };
21054     } catch (...) {
21055       {
21056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21057       };
21058     }
21059   }
21060
21061 }
21062
21063
21064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemovePropertyNotifications(void * jarg1) {
21065   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21066
21067   arg1 = (Dali::Handle *)jarg1;
21068   {
21069     try {
21070       (arg1)->RemovePropertyNotifications();
21071     } catch (std::out_of_range& e) {
21072       {
21073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21074       };
21075     } catch (std::exception& e) {
21076       {
21077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21078       };
21079     } catch (Dali::DaliException e) {
21080       {
21081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21082       };
21083     } catch (...) {
21084       {
21085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21086       };
21087     }
21088   }
21089
21090 }
21091
21092
21093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_0(void * jarg1) {
21094   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21095
21096   arg1 = (Dali::Handle *)jarg1;
21097   {
21098     try {
21099       (arg1)->RemoveConstraints();
21100     } catch (std::out_of_range& e) {
21101       {
21102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21103       };
21104     } catch (std::exception& e) {
21105       {
21106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21107       };
21108     } catch (Dali::DaliException e) {
21109       {
21110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21111       };
21112     } catch (...) {
21113       {
21114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21115       };
21116     }
21117   }
21118
21119 }
21120
21121
21122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Handle_RemoveConstraints__SWIG_1(void * jarg1, unsigned int jarg2) {
21123   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
21124   unsigned int arg2 ;
21125
21126   arg1 = (Dali::Handle *)jarg1;
21127   arg2 = (unsigned int)jarg2;
21128   {
21129     try {
21130       (arg1)->RemoveConstraints(arg2);
21131     } catch (std::out_of_range& e) {
21132       {
21133         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21134       };
21135     } catch (std::exception& e) {
21136       {
21137         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21138       };
21139     } catch (Dali::DaliException e) {
21140       {
21141         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21142       };
21143     } catch (...) {
21144       {
21145         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21146       };
21147     }
21148   }
21149
21150 }
21151
21152
21153 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WEIGHT_get() {
21154   int jresult ;
21155   Dali::Property::Index result;
21156
21157   result = (Dali::Property::Index)(Dali::Property::Index)Dali::WeightObject::WEIGHT;
21158   jresult = result;
21159   return jresult;
21160 }
21161
21162
21163 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_New() {
21164   void * jresult ;
21165   Dali::Handle result;
21166
21167   {
21168     try {
21169       result = Dali::WeightObject::New();
21170     } catch (std::out_of_range& e) {
21171       {
21172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21173       };
21174     } catch (std::exception& e) {
21175       {
21176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21177       };
21178     } catch (Dali::DaliException e) {
21179       {
21180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21181       };
21182     } catch (...) {
21183       {
21184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21185       };
21186     }
21187   }
21188
21189   jresult = new Dali::Handle((const Dali::Handle &)result);
21190   return jresult;
21191 }
21192
21193
21194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_0() {
21195   void * jresult ;
21196   Dali::TypeInfo *result = 0 ;
21197
21198   {
21199     try {
21200       result = (Dali::TypeInfo *)new Dali::TypeInfo();
21201     } catch (std::out_of_range& e) {
21202       {
21203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21204       };
21205     } catch (std::exception& e) {
21206       {
21207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21208       };
21209     } catch (Dali::DaliException e) {
21210       {
21211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21212       };
21213     } catch (...) {
21214       {
21215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21216       };
21217     }
21218   }
21219
21220   jresult = (void *)result;
21221   return jresult;
21222 }
21223
21224
21225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeInfo(void * jarg1) {
21226   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21227
21228   arg1 = (Dali::TypeInfo *)jarg1;
21229   {
21230     try {
21231       delete arg1;
21232     } catch (std::out_of_range& e) {
21233       {
21234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21235       };
21236     } catch (std::exception& e) {
21237       {
21238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21239       };
21240     } catch (Dali::DaliException e) {
21241       {
21242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21243       };
21244     } catch (...) {
21245       {
21246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21247       };
21248     }
21249   }
21250
21251 }
21252
21253
21254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeInfo__SWIG_1(void * jarg1) {
21255   void * jresult ;
21256   Dali::TypeInfo *arg1 = 0 ;
21257   Dali::TypeInfo *result = 0 ;
21258
21259   arg1 = (Dali::TypeInfo *)jarg1;
21260   if (!arg1) {
21261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21262     return 0;
21263   }
21264   {
21265     try {
21266       result = (Dali::TypeInfo *)new Dali::TypeInfo((Dali::TypeInfo const &)*arg1);
21267     } catch (std::out_of_range& e) {
21268       {
21269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21270       };
21271     } catch (std::exception& e) {
21272       {
21273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21274       };
21275     } catch (Dali::DaliException e) {
21276       {
21277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21278       };
21279     } catch (...) {
21280       {
21281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21282       };
21283     }
21284   }
21285
21286   jresult = (void *)result;
21287   return jresult;
21288 }
21289
21290
21291 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_Assign(void * jarg1, void * jarg2) {
21292   void * jresult ;
21293   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21294   Dali::TypeInfo *arg2 = 0 ;
21295   Dali::TypeInfo *result = 0 ;
21296
21297   arg1 = (Dali::TypeInfo *)jarg1;
21298   arg2 = (Dali::TypeInfo *)jarg2;
21299   if (!arg2) {
21300     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeInfo const & type is null", 0);
21301     return 0;
21302   }
21303   {
21304     try {
21305       result = (Dali::TypeInfo *) &(arg1)->operator =((Dali::TypeInfo const &)*arg2);
21306     } catch (std::out_of_range& e) {
21307       {
21308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21309       };
21310     } catch (std::exception& e) {
21311       {
21312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21313       };
21314     } catch (Dali::DaliException e) {
21315       {
21316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21317       };
21318     } catch (...) {
21319       {
21320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21321       };
21322     }
21323   }
21324
21325   jresult = (void *)result;
21326   return jresult;
21327 }
21328
21329
21330 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetName(void * jarg1) {
21331   char * jresult ;
21332   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21333   std::string *result = 0 ;
21334
21335   arg1 = (Dali::TypeInfo *)jarg1;
21336   {
21337     try {
21338       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetName();
21339     } catch (std::out_of_range& e) {
21340       {
21341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21342       };
21343     } catch (std::exception& e) {
21344       {
21345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21346       };
21347     } catch (Dali::DaliException e) {
21348       {
21349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21350       };
21351     } catch (...) {
21352       {
21353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21354       };
21355     }
21356   }
21357
21358   jresult = SWIG_csharp_string_callback(result->c_str());
21359   return jresult;
21360 }
21361
21362
21363 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetBaseName(void * jarg1) {
21364   char * jresult ;
21365   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21366   std::string *result = 0 ;
21367
21368   arg1 = (Dali::TypeInfo *)jarg1;
21369   {
21370     try {
21371       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetBaseName();
21372     } catch (std::out_of_range& e) {
21373       {
21374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21375       };
21376     } catch (std::exception& e) {
21377       {
21378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21379       };
21380     } catch (Dali::DaliException e) {
21381       {
21382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21383       };
21384     } catch (...) {
21385       {
21386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21387       };
21388     }
21389   }
21390
21391   jresult = SWIG_csharp_string_callback(result->c_str());
21392   return jresult;
21393 }
21394
21395
21396 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeInfo_CreateInstance(void * jarg1) {
21397   void * jresult ;
21398   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21399   Dali::BaseHandle result;
21400
21401   arg1 = (Dali::TypeInfo *)jarg1;
21402   {
21403     try {
21404       result = ((Dali::TypeInfo const *)arg1)->CreateInstance();
21405     } catch (std::out_of_range& e) {
21406       {
21407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21408       };
21409     } catch (std::exception& e) {
21410       {
21411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21412       };
21413     } catch (Dali::DaliException e) {
21414       {
21415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21416       };
21417     } catch (...) {
21418       {
21419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21420       };
21421     }
21422   }
21423
21424   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
21425   return jresult;
21426 }
21427
21428
21429 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionCount(void * jarg1) {
21430   unsigned long jresult ;
21431   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21432   size_t result;
21433
21434   arg1 = (Dali::TypeInfo *)jarg1;
21435   {
21436     try {
21437       result = ((Dali::TypeInfo const *)arg1)->GetActionCount();
21438     } catch (std::out_of_range& e) {
21439       {
21440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21441       };
21442     } catch (std::exception& e) {
21443       {
21444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21445       };
21446     } catch (Dali::DaliException e) {
21447       {
21448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21449       };
21450     } catch (...) {
21451       {
21452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21453       };
21454     }
21455   }
21456
21457   jresult = (unsigned long)result;
21458   return jresult;
21459 }
21460
21461
21462 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetActionName(void * jarg1, unsigned long jarg2) {
21463   char * jresult ;
21464   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21465   size_t arg2 ;
21466   std::string result;
21467
21468   arg1 = (Dali::TypeInfo *)jarg1;
21469   arg2 = (size_t)jarg2;
21470   {
21471     try {
21472       result = (arg1)->GetActionName(arg2);
21473     } catch (std::out_of_range& e) {
21474       {
21475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21476       };
21477     } catch (std::exception& e) {
21478       {
21479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21480       };
21481     } catch (Dali::DaliException e) {
21482       {
21483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21484       };
21485     } catch (...) {
21486       {
21487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21488       };
21489     }
21490   }
21491
21492   jresult = SWIG_csharp_string_callback((&result)->c_str());
21493   return jresult;
21494 }
21495
21496
21497 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalCount(void * jarg1) {
21498   unsigned long jresult ;
21499   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21500   size_t result;
21501
21502   arg1 = (Dali::TypeInfo *)jarg1;
21503   {
21504     try {
21505       result = ((Dali::TypeInfo const *)arg1)->GetSignalCount();
21506     } catch (std::out_of_range& e) {
21507       {
21508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21509       };
21510     } catch (std::exception& e) {
21511       {
21512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21513       };
21514     } catch (Dali::DaliException e) {
21515       {
21516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21517       };
21518     } catch (...) {
21519       {
21520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21521       };
21522     }
21523   }
21524
21525   jresult = (unsigned long)result;
21526   return jresult;
21527 }
21528
21529
21530 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetSignalName(void * jarg1, unsigned long jarg2) {
21531   char * jresult ;
21532   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21533   size_t arg2 ;
21534   std::string result;
21535
21536   arg1 = (Dali::TypeInfo *)jarg1;
21537   arg2 = (size_t)jarg2;
21538   {
21539     try {
21540       result = (arg1)->GetSignalName(arg2);
21541     } catch (std::out_of_range& e) {
21542       {
21543         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21544       };
21545     } catch (std::exception& e) {
21546       {
21547         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21548       };
21549     } catch (Dali::DaliException e) {
21550       {
21551         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21552       };
21553     } catch (...) {
21554       {
21555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21556       };
21557     }
21558   }
21559
21560   jresult = SWIG_csharp_string_callback((&result)->c_str());
21561   return jresult;
21562 }
21563
21564
21565 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyCount(void * jarg1) {
21566   unsigned long jresult ;
21567   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21568   size_t result;
21569
21570   arg1 = (Dali::TypeInfo *)jarg1;
21571   {
21572     try {
21573       result = ((Dali::TypeInfo const *)arg1)->GetPropertyCount();
21574     } catch (std::out_of_range& e) {
21575       {
21576         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21577       };
21578     } catch (std::exception& e) {
21579       {
21580         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21581       };
21582     } catch (Dali::DaliException e) {
21583       {
21584         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21585       };
21586     } catch (...) {
21587       {
21588         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21589       };
21590     }
21591   }
21592
21593   jresult = (unsigned long)result;
21594   return jresult;
21595 }
21596
21597
21598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyIndices(void * jarg1, void * jarg2) {
21599   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21600   Dali::Property::IndexContainer *arg2 = 0 ;
21601
21602   arg1 = (Dali::TypeInfo *)jarg1;
21603   arg2 = (Dali::Property::IndexContainer *)jarg2;
21604   if (!arg2) {
21605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::IndexContainer & type is null", 0);
21606     return ;
21607   }
21608   {
21609     try {
21610       ((Dali::TypeInfo const *)arg1)->GetPropertyIndices(*arg2);
21611     } catch (std::out_of_range& e) {
21612       {
21613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21614       };
21615     } catch (std::exception& e) {
21616       {
21617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21618       };
21619     } catch (Dali::DaliException e) {
21620       {
21621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21622       };
21623     } catch (...) {
21624       {
21625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21626       };
21627     }
21628   }
21629
21630 }
21631
21632
21633 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeInfo_GetPropertyName(void * jarg1, int jarg2) {
21634   char * jresult ;
21635   Dali::TypeInfo *arg1 = (Dali::TypeInfo *) 0 ;
21636   Dali::Property::Index arg2 ;
21637   std::string *result = 0 ;
21638
21639   arg1 = (Dali::TypeInfo *)jarg1;
21640   arg2 = (Dali::Property::Index)jarg2;
21641   {
21642     try {
21643       result = (std::string *) &((Dali::TypeInfo const *)arg1)->GetPropertyName(arg2);
21644     } catch (std::out_of_range& e) {
21645       {
21646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21647       };
21648     } catch (std::exception& e) {
21649       {
21650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21651       };
21652     } catch (Dali::DaliException e) {
21653       {
21654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21655       };
21656     } catch (...) {
21657       {
21658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21659       };
21660     }
21661   }
21662
21663   jresult = SWIG_csharp_string_callback(result->c_str());
21664   return jresult;
21665 }
21666
21667
21668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Get() {
21669   void * jresult ;
21670   Dali::TypeRegistry result;
21671
21672   {
21673     try {
21674       result = Dali::TypeRegistry::Get();
21675     } catch (std::out_of_range& e) {
21676       {
21677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21678       };
21679     } catch (std::exception& e) {
21680       {
21681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21682       };
21683     } catch (Dali::DaliException e) {
21684       {
21685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21686       };
21687     } catch (...) {
21688       {
21689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21690       };
21691     }
21692   }
21693
21694   jresult = new Dali::TypeRegistry((const Dali::TypeRegistry &)result);
21695   return jresult;
21696 }
21697
21698
21699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_0() {
21700   void * jresult ;
21701   Dali::TypeRegistry *result = 0 ;
21702
21703   {
21704     try {
21705       result = (Dali::TypeRegistry *)new Dali::TypeRegistry();
21706     } catch (std::out_of_range& e) {
21707       {
21708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21709       };
21710     } catch (std::exception& e) {
21711       {
21712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21713       };
21714     } catch (Dali::DaliException e) {
21715       {
21716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21717       };
21718     } catch (...) {
21719       {
21720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21721       };
21722     }
21723   }
21724
21725   jresult = (void *)result;
21726   return jresult;
21727 }
21728
21729
21730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistry(void * jarg1) {
21731   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21732
21733   arg1 = (Dali::TypeRegistry *)jarg1;
21734   {
21735     try {
21736       delete arg1;
21737     } catch (std::out_of_range& e) {
21738       {
21739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
21740       };
21741     } catch (std::exception& e) {
21742       {
21743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
21744       };
21745     } catch (Dali::DaliException e) {
21746       {
21747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
21748       };
21749     } catch (...) {
21750       {
21751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
21752       };
21753     }
21754   }
21755
21756 }
21757
21758
21759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistry__SWIG_1(void * jarg1) {
21760   void * jresult ;
21761   Dali::TypeRegistry *arg1 = 0 ;
21762   Dali::TypeRegistry *result = 0 ;
21763
21764   arg1 = (Dali::TypeRegistry *)jarg1;
21765   if (!arg1) {
21766     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21767     return 0;
21768   }
21769   {
21770     try {
21771       result = (Dali::TypeRegistry *)new Dali::TypeRegistry((Dali::TypeRegistry const &)*arg1);
21772     } catch (std::out_of_range& e) {
21773       {
21774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21775       };
21776     } catch (std::exception& e) {
21777       {
21778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21779       };
21780     } catch (Dali::DaliException e) {
21781       {
21782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21783       };
21784     } catch (...) {
21785       {
21786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21787       };
21788     }
21789   }
21790
21791   jresult = (void *)result;
21792   return jresult;
21793 }
21794
21795
21796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_Assign(void * jarg1, void * jarg2) {
21797   void * jresult ;
21798   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21799   Dali::TypeRegistry *arg2 = 0 ;
21800   Dali::TypeRegistry *result = 0 ;
21801
21802   arg1 = (Dali::TypeRegistry *)jarg1;
21803   arg2 = (Dali::TypeRegistry *)jarg2;
21804   if (!arg2) {
21805     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistry const & type is null", 0);
21806     return 0;
21807   }
21808   {
21809     try {
21810       result = (Dali::TypeRegistry *) &(arg1)->operator =((Dali::TypeRegistry const &)*arg2);
21811     } catch (std::out_of_range& e) {
21812       {
21813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21814       };
21815     } catch (std::exception& e) {
21816       {
21817         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21818       };
21819     } catch (Dali::DaliException e) {
21820       {
21821         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21822       };
21823     } catch (...) {
21824       {
21825         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21826       };
21827     }
21828   }
21829
21830   jresult = (void *)result;
21831   return jresult;
21832 }
21833
21834
21835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_0(void * jarg1, char * jarg2) {
21836   void * jresult ;
21837   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21838   std::string *arg2 = 0 ;
21839   Dali::TypeInfo result;
21840
21841   arg1 = (Dali::TypeRegistry *)jarg1;
21842   if (!jarg2) {
21843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
21844     return 0;
21845   }
21846   std::string arg2_str(jarg2);
21847   arg2 = &arg2_str;
21848   {
21849     try {
21850       result = (arg1)->GetTypeInfo((std::string const &)*arg2);
21851     } catch (std::out_of_range& e) {
21852       {
21853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21854       };
21855     } catch (std::exception& e) {
21856       {
21857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21858       };
21859     } catch (Dali::DaliException e) {
21860       {
21861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21862       };
21863     } catch (...) {
21864       {
21865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21866       };
21867     }
21868   }
21869
21870   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21871
21872   //argout typemap for const std::string&
21873
21874   return jresult;
21875 }
21876
21877
21878 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeInfo__SWIG_1(void * jarg1, void * jarg2) {
21879   void * jresult ;
21880   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21881   std::type_info *arg2 = 0 ;
21882   Dali::TypeInfo result;
21883
21884   arg1 = (Dali::TypeRegistry *)jarg1;
21885   arg2 = (std::type_info *)jarg2;
21886   if (!arg2) {
21887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21888     return 0;
21889   }
21890   {
21891     try {
21892       result = (arg1)->GetTypeInfo((std::type_info const &)*arg2);
21893     } catch (std::out_of_range& e) {
21894       {
21895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21896       };
21897     } catch (std::exception& e) {
21898       {
21899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21900       };
21901     } catch (Dali::DaliException e) {
21902       {
21903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21904       };
21905     } catch (...) {
21906       {
21907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21908       };
21909     }
21910   }
21911
21912   jresult = new Dali::TypeInfo((const Dali::TypeInfo &)result);
21913   return jresult;
21914 }
21915
21916
21917 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeNameCount(void * jarg1) {
21918   unsigned long jresult ;
21919   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21920   size_t result;
21921
21922   arg1 = (Dali::TypeRegistry *)jarg1;
21923   {
21924     try {
21925       result = ((Dali::TypeRegistry const *)arg1)->GetTypeNameCount();
21926     } catch (std::out_of_range& e) {
21927       {
21928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21929       };
21930     } catch (std::exception& e) {
21931       {
21932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21933       };
21934     } catch (Dali::DaliException e) {
21935       {
21936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21937       };
21938     } catch (...) {
21939       {
21940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21941       };
21942     }
21943   }
21944
21945   jresult = (unsigned long)result;
21946   return jresult;
21947 }
21948
21949
21950 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistry_GetTypeName(void * jarg1, unsigned long jarg2) {
21951   char * jresult ;
21952   Dali::TypeRegistry *arg1 = (Dali::TypeRegistry *) 0 ;
21953   size_t arg2 ;
21954   std::string result;
21955
21956   arg1 = (Dali::TypeRegistry *)jarg1;
21957   arg2 = (size_t)jarg2;
21958   {
21959     try {
21960       result = ((Dali::TypeRegistry const *)arg1)->GetTypeName(arg2);
21961     } catch (std::out_of_range& e) {
21962       {
21963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
21964       };
21965     } catch (std::exception& e) {
21966       {
21967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
21968       };
21969     } catch (Dali::DaliException e) {
21970       {
21971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
21972       };
21973     } catch (...) {
21974       {
21975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
21976       };
21977     }
21978   }
21979
21980   jresult = SWIG_csharp_string_callback((&result)->c_str());
21981   return jresult;
21982 }
21983
21984
21985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
21986   void * jresult ;
21987   std::type_info *arg1 = 0 ;
21988   std::type_info *arg2 = 0 ;
21989   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
21990   Dali::TypeRegistration *result = 0 ;
21991
21992   arg1 = (std::type_info *)jarg1;
21993   if (!arg1) {
21994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
21995     return 0;
21996   }
21997   arg2 = (std::type_info *)jarg2;
21998   if (!arg2) {
21999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22000     return 0;
22001   }
22002   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22003   {
22004     try {
22005       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3);
22006     } catch (std::out_of_range& e) {
22007       {
22008         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22009       };
22010     } catch (std::exception& e) {
22011       {
22012         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22013       };
22014     } catch (Dali::DaliException e) {
22015       {
22016         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22017       };
22018     } catch (...) {
22019       {
22020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22021       };
22022     }
22023   }
22024
22025   jresult = (void *)result;
22026   return jresult;
22027 }
22028
22029
22030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_1(void * jarg1, void * jarg2, void * jarg3, unsigned int jarg4) {
22031   void * jresult ;
22032   std::type_info *arg1 = 0 ;
22033   std::type_info *arg2 = 0 ;
22034   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22035   bool arg4 ;
22036   Dali::TypeRegistration *result = 0 ;
22037
22038   arg1 = (std::type_info *)jarg1;
22039   if (!arg1) {
22040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22041     return 0;
22042   }
22043   arg2 = (std::type_info *)jarg2;
22044   if (!arg2) {
22045     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22046     return 0;
22047   }
22048   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22049   arg4 = jarg4 ? true : false;
22050   {
22051     try {
22052       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::type_info const &)*arg1,(std::type_info const &)*arg2,arg3,arg4);
22053     } catch (std::out_of_range& e) {
22054       {
22055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22056       };
22057     } catch (std::exception& e) {
22058       {
22059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22060       };
22061     } catch (Dali::DaliException e) {
22062       {
22063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22064       };
22065     } catch (...) {
22066       {
22067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22068       };
22069     }
22070   }
22071
22072   jresult = (void *)result;
22073   return jresult;
22074 }
22075
22076
22077 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeRegistration__SWIG_2(char * jarg1, void * jarg2, void * jarg3) {
22078   void * jresult ;
22079   std::string *arg1 = 0 ;
22080   std::type_info *arg2 = 0 ;
22081   Dali::TypeInfo::CreateFunction arg3 = (Dali::TypeInfo::CreateFunction) 0 ;
22082   Dali::TypeRegistration *result = 0 ;
22083
22084   if (!jarg1) {
22085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22086     return 0;
22087   }
22088   std::string arg1_str(jarg1);
22089   arg1 = &arg1_str;
22090   arg2 = (std::type_info *)jarg2;
22091   if (!arg2) {
22092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22093     return 0;
22094   }
22095   arg3 = (Dali::TypeInfo::CreateFunction)jarg3;
22096   {
22097     try {
22098       result = (Dali::TypeRegistration *)new Dali::TypeRegistration((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22099     } catch (std::out_of_range& e) {
22100       {
22101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22102       };
22103     } catch (std::exception& e) {
22104       {
22105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22106       };
22107     } catch (Dali::DaliException e) {
22108       {
22109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22110       };
22111     } catch (...) {
22112       {
22113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22114       };
22115     }
22116   }
22117
22118   jresult = (void *)result;
22119
22120   //argout typemap for const std::string&
22121
22122   return jresult;
22123 }
22124
22125
22126 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisteredName(void * jarg1) {
22127   char * jresult ;
22128   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22129   std::string result;
22130
22131   arg1 = (Dali::TypeRegistration *)jarg1;
22132   {
22133     try {
22134       result = ((Dali::TypeRegistration const *)arg1)->RegisteredName();
22135     } catch (std::out_of_range& e) {
22136       {
22137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22138       };
22139     } catch (std::exception& e) {
22140       {
22141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22142       };
22143     } catch (Dali::DaliException e) {
22144       {
22145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22146       };
22147     } catch (...) {
22148       {
22149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22150       };
22151     }
22152   }
22153
22154   jresult = SWIG_csharp_string_callback((&result)->c_str());
22155   return jresult;
22156 }
22157
22158
22159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterControl(char * jarg1, void * jarg2) {
22160   std::string *arg1 = 0 ;
22161   Dali::CSharpTypeInfo::CreateFunction arg2 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22162
22163   if (!jarg1) {
22164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22165     return ;
22166   }
22167   std::string arg1_str(jarg1);
22168   arg1 = &arg1_str;
22169   arg2 = (Dali::CSharpTypeInfo::CreateFunction)jarg2;
22170   {
22171     try {
22172       Dali_TypeRegistration_RegisterControl((std::string const &)*arg1,arg2);
22173     } catch (std::out_of_range& e) {
22174       {
22175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22176       };
22177     } catch (std::exception& e) {
22178       {
22179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22180       };
22181     } catch (Dali::DaliException e) {
22182       {
22183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22184       };
22185     } catch (...) {
22186       {
22187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22188       };
22189     }
22190   }
22191
22192
22193   //argout typemap for const std::string&
22194
22195 }
22196
22197
22198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TypeRegistration_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22199   std::string *arg1 = 0 ;
22200   std::string *arg2 = 0 ;
22201   int arg3 ;
22202   Dali::Property::Type arg4 ;
22203   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22204   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22205
22206   if (!jarg1) {
22207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22208     return ;
22209   }
22210   std::string arg1_str(jarg1);
22211   arg1 = &arg1_str;
22212   if (!jarg2) {
22213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22214     return ;
22215   }
22216   std::string arg2_str(jarg2);
22217   arg2 = &arg2_str;
22218   arg3 = (int)jarg3;
22219   arg4 = (Dali::Property::Type)jarg4;
22220   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22221   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22222   {
22223     try {
22224       Dali_TypeRegistration_RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22225     } catch (std::out_of_range& e) {
22226       {
22227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22228       };
22229     } catch (std::exception& e) {
22230       {
22231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22232       };
22233     } catch (Dali::DaliException e) {
22234       {
22235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22236       };
22237     } catch (...) {
22238       {
22239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22240       };
22241     }
22242   }
22243
22244
22245   //argout typemap for const std::string&
22246
22247
22248   //argout typemap for const std::string&
22249
22250 }
22251
22252
22253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeRegistration(void * jarg1) {
22254   Dali::TypeRegistration *arg1 = (Dali::TypeRegistration *) 0 ;
22255
22256   arg1 = (Dali::TypeRegistration *)jarg1;
22257   {
22258     try {
22259       delete arg1;
22260     } catch (std::out_of_range& e) {
22261       {
22262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22263       };
22264     } catch (std::exception& e) {
22265       {
22266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22267       };
22268     } catch (Dali::DaliException e) {
22269       {
22270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22271       };
22272     } catch (...) {
22273       {
22274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22275       };
22276     }
22277   }
22278
22279 }
22280
22281
22282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SignalConnectorType(void * jarg1, char * jarg2, void * jarg3) {
22283   void * jresult ;
22284   Dali::TypeRegistration *arg1 = 0 ;
22285   std::string *arg2 = 0 ;
22286   Dali::TypeInfo::SignalConnectorFunction arg3 = (Dali::TypeInfo::SignalConnectorFunction) 0 ;
22287   Dali::SignalConnectorType *result = 0 ;
22288
22289   arg1 = (Dali::TypeRegistration *)jarg1;
22290   if (!arg1) {
22291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22292     return 0;
22293   }
22294   if (!jarg2) {
22295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22296     return 0;
22297   }
22298   std::string arg2_str(jarg2);
22299   arg2 = &arg2_str;
22300   arg3 = (Dali::TypeInfo::SignalConnectorFunction)jarg3;
22301   {
22302     try {
22303       result = (Dali::SignalConnectorType *)new Dali::SignalConnectorType(*arg1,(std::string const &)*arg2,arg3);
22304     } catch (std::out_of_range& e) {
22305       {
22306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22307       };
22308     } catch (std::exception& e) {
22309       {
22310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22311       };
22312     } catch (Dali::DaliException e) {
22313       {
22314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22315       };
22316     } catch (...) {
22317       {
22318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22319       };
22320     }
22321   }
22322
22323   jresult = (void *)result;
22324
22325   //argout typemap for const std::string&
22326
22327   return jresult;
22328 }
22329
22330
22331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SignalConnectorType(void * jarg1) {
22332   Dali::SignalConnectorType *arg1 = (Dali::SignalConnectorType *) 0 ;
22333
22334   arg1 = (Dali::SignalConnectorType *)jarg1;
22335   {
22336     try {
22337       delete arg1;
22338     } catch (std::out_of_range& e) {
22339       {
22340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22341       };
22342     } catch (std::exception& e) {
22343       {
22344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22345       };
22346     } catch (Dali::DaliException e) {
22347       {
22348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22349       };
22350     } catch (...) {
22351       {
22352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22353       };
22354     }
22355   }
22356
22357 }
22358
22359
22360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TypeAction(void * jarg1, char * jarg2, void * jarg3) {
22361   void * jresult ;
22362   Dali::TypeRegistration *arg1 = 0 ;
22363   std::string *arg2 = 0 ;
22364   Dali::TypeInfo::ActionFunction arg3 = (Dali::TypeInfo::ActionFunction) 0 ;
22365   Dali::TypeAction *result = 0 ;
22366
22367   arg1 = (Dali::TypeRegistration *)jarg1;
22368   if (!arg1) {
22369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22370     return 0;
22371   }
22372   if (!jarg2) {
22373     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22374     return 0;
22375   }
22376   std::string arg2_str(jarg2);
22377   arg2 = &arg2_str;
22378   arg3 = (Dali::TypeInfo::ActionFunction)jarg3;
22379   {
22380     try {
22381       result = (Dali::TypeAction *)new Dali::TypeAction(*arg1,(std::string const &)*arg2,arg3);
22382     } catch (std::out_of_range& e) {
22383       {
22384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22385       };
22386     } catch (std::exception& e) {
22387       {
22388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22389       };
22390     } catch (Dali::DaliException e) {
22391       {
22392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22393       };
22394     } catch (...) {
22395       {
22396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22397       };
22398     }
22399   }
22400
22401   jresult = (void *)result;
22402
22403   //argout typemap for const std::string&
22404
22405   return jresult;
22406 }
22407
22408
22409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TypeAction(void * jarg1) {
22410   Dali::TypeAction *arg1 = (Dali::TypeAction *) 0 ;
22411
22412   arg1 = (Dali::TypeAction *)jarg1;
22413   {
22414     try {
22415       delete arg1;
22416     } catch (std::out_of_range& e) {
22417       {
22418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22419       };
22420     } catch (std::exception& e) {
22421       {
22422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22423       };
22424     } catch (Dali::DaliException e) {
22425       {
22426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22427       };
22428     } catch (...) {
22429       {
22430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22431       };
22432     }
22433   }
22434
22435 }
22436
22437
22438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22439   void * jresult ;
22440   Dali::TypeRegistration *arg1 = 0 ;
22441   std::string *arg2 = 0 ;
22442   Dali::Property::Index arg3 ;
22443   Dali::Property::Type arg4 ;
22444   Dali::TypeInfo::SetPropertyFunction arg5 = (Dali::TypeInfo::SetPropertyFunction) 0 ;
22445   Dali::TypeInfo::GetPropertyFunction arg6 = (Dali::TypeInfo::GetPropertyFunction) 0 ;
22446   Dali::PropertyRegistration *result = 0 ;
22447
22448   arg1 = (Dali::TypeRegistration *)jarg1;
22449   if (!arg1) {
22450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22451     return 0;
22452   }
22453   if (!jarg2) {
22454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22455     return 0;
22456   }
22457   std::string arg2_str(jarg2);
22458   arg2 = &arg2_str;
22459   arg3 = (Dali::Property::Index)jarg3;
22460   arg4 = (Dali::Property::Type)jarg4;
22461   arg5 = (Dali::TypeInfo::SetPropertyFunction)jarg5;
22462   arg6 = (Dali::TypeInfo::GetPropertyFunction)jarg6;
22463   {
22464     try {
22465       result = (Dali::PropertyRegistration *)new Dali::PropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22466     } catch (std::out_of_range& e) {
22467       {
22468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22469       };
22470     } catch (std::exception& e) {
22471       {
22472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22473       };
22474     } catch (Dali::DaliException e) {
22475       {
22476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22477       };
22478     } catch (...) {
22479       {
22480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22481       };
22482     }
22483   }
22484
22485   jresult = (void *)result;
22486
22487   //argout typemap for const std::string&
22488
22489   return jresult;
22490 }
22491
22492
22493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyRegistration(void * jarg1) {
22494   Dali::PropertyRegistration *arg1 = (Dali::PropertyRegistration *) 0 ;
22495
22496   arg1 = (Dali::PropertyRegistration *)jarg1;
22497   {
22498     try {
22499       delete arg1;
22500     } catch (std::out_of_range& e) {
22501       {
22502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22503       };
22504     } catch (std::exception& e) {
22505       {
22506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22507       };
22508     } catch (Dali::DaliException e) {
22509       {
22510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22511       };
22512     } catch (...) {
22513       {
22514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22515       };
22516     }
22517   }
22518
22519 }
22520
22521
22522 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22523   void * jresult ;
22524   Dali::TypeRegistration *arg1 = 0 ;
22525   std::string *arg2 = 0 ;
22526   Dali::Property::Index arg3 ;
22527   Dali::Property::Type arg4 ;
22528   Dali::AnimatablePropertyRegistration *result = 0 ;
22529
22530   arg1 = (Dali::TypeRegistration *)jarg1;
22531   if (!arg1) {
22532     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22533     return 0;
22534   }
22535   if (!jarg2) {
22536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22537     return 0;
22538   }
22539   std::string arg2_str(jarg2);
22540   arg2 = &arg2_str;
22541   arg3 = (Dali::Property::Index)jarg3;
22542   arg4 = (Dali::Property::Type)jarg4;
22543   {
22544     try {
22545       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22546     } catch (std::out_of_range& e) {
22547       {
22548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22549       };
22550     } catch (std::exception& e) {
22551       {
22552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22553       };
22554     } catch (Dali::DaliException e) {
22555       {
22556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22557       };
22558     } catch (...) {
22559       {
22560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22561       };
22562     }
22563   }
22564
22565   jresult = (void *)result;
22566
22567   //argout typemap for const std::string&
22568
22569   return jresult;
22570 }
22571
22572
22573 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyRegistration__SWIG_1(void * jarg1, char * jarg2, int jarg3, void * jarg4) {
22574   void * jresult ;
22575   Dali::TypeRegistration *arg1 = 0 ;
22576   std::string *arg2 = 0 ;
22577   Dali::Property::Index arg3 ;
22578   Dali::Property::Value *arg4 = 0 ;
22579   Dali::AnimatablePropertyRegistration *result = 0 ;
22580
22581   arg1 = (Dali::TypeRegistration *)jarg1;
22582   if (!arg1) {
22583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22584     return 0;
22585   }
22586   if (!jarg2) {
22587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22588     return 0;
22589   }
22590   std::string arg2_str(jarg2);
22591   arg2 = &arg2_str;
22592   arg3 = (Dali::Property::Index)jarg3;
22593   arg4 = (Dali::Property::Value *)jarg4;
22594   if (!arg4) {
22595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
22596     return 0;
22597   }
22598   {
22599     try {
22600       result = (Dali::AnimatablePropertyRegistration *)new Dali::AnimatablePropertyRegistration(*arg1,(std::string const &)*arg2,arg3,(Dali::Property::Value const &)*arg4);
22601     } catch (std::out_of_range& e) {
22602       {
22603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22604       };
22605     } catch (std::exception& e) {
22606       {
22607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22608       };
22609     } catch (Dali::DaliException e) {
22610       {
22611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22612       };
22613     } catch (...) {
22614       {
22615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22616       };
22617     }
22618   }
22619
22620   jresult = (void *)result;
22621
22622   //argout typemap for const std::string&
22623
22624   return jresult;
22625 }
22626
22627
22628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyRegistration(void * jarg1) {
22629   Dali::AnimatablePropertyRegistration *arg1 = (Dali::AnimatablePropertyRegistration *) 0 ;
22630
22631   arg1 = (Dali::AnimatablePropertyRegistration *)jarg1;
22632   {
22633     try {
22634       delete arg1;
22635     } catch (std::out_of_range& e) {
22636       {
22637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22638       };
22639     } catch (std::exception& e) {
22640       {
22641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22642       };
22643     } catch (Dali::DaliException e) {
22644       {
22645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22646       };
22647     } catch (...) {
22648       {
22649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22650       };
22651     }
22652   }
22653
22654 }
22655
22656
22657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AnimatablePropertyComponentRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
22658   void * jresult ;
22659   Dali::TypeRegistration *arg1 = 0 ;
22660   std::string *arg2 = 0 ;
22661   Dali::Property::Index arg3 ;
22662   Dali::Property::Index arg4 ;
22663   unsigned int arg5 ;
22664   Dali::AnimatablePropertyComponentRegistration *result = 0 ;
22665
22666   arg1 = (Dali::TypeRegistration *)jarg1;
22667   if (!arg1) {
22668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22669     return 0;
22670   }
22671   if (!jarg2) {
22672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22673     return 0;
22674   }
22675   std::string arg2_str(jarg2);
22676   arg2 = &arg2_str;
22677   arg3 = (Dali::Property::Index)jarg3;
22678   arg4 = (Dali::Property::Index)jarg4;
22679   arg5 = (unsigned int)jarg5;
22680   {
22681     try {
22682       result = (Dali::AnimatablePropertyComponentRegistration *)new Dali::AnimatablePropertyComponentRegistration(*arg1,(std::string const &)*arg2,arg3,arg4,arg5);
22683     } catch (std::out_of_range& e) {
22684       {
22685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22686       };
22687     } catch (std::exception& e) {
22688       {
22689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22690       };
22691     } catch (Dali::DaliException e) {
22692       {
22693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22694       };
22695     } catch (...) {
22696       {
22697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22698       };
22699     }
22700   }
22701
22702   jresult = (void *)result;
22703
22704   //argout typemap for const std::string&
22705
22706   return jresult;
22707 }
22708
22709
22710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AnimatablePropertyComponentRegistration(void * jarg1) {
22711   Dali::AnimatablePropertyComponentRegistration *arg1 = (Dali::AnimatablePropertyComponentRegistration *) 0 ;
22712
22713   arg1 = (Dali::AnimatablePropertyComponentRegistration *)jarg1;
22714   {
22715     try {
22716       delete arg1;
22717     } catch (std::out_of_range& e) {
22718       {
22719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22720       };
22721     } catch (std::exception& e) {
22722       {
22723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22724       };
22725     } catch (Dali::DaliException e) {
22726       {
22727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22728       };
22729     } catch (...) {
22730       {
22731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22732       };
22733     }
22734   }
22735
22736 }
22737
22738
22739 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ChildPropertyRegistration(void * jarg1, char * jarg2, int jarg3, int jarg4) {
22740   void * jresult ;
22741   Dali::TypeRegistration *arg1 = 0 ;
22742   std::string *arg2 = 0 ;
22743   Dali::Property::Index arg3 ;
22744   Dali::Property::Type arg4 ;
22745   Dali::ChildPropertyRegistration *result = 0 ;
22746
22747   arg1 = (Dali::TypeRegistration *)jarg1;
22748   if (!arg1) {
22749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TypeRegistration & type is null", 0);
22750     return 0;
22751   }
22752   if (!jarg2) {
22753     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22754     return 0;
22755   }
22756   std::string arg2_str(jarg2);
22757   arg2 = &arg2_str;
22758   arg3 = (Dali::Property::Index)jarg3;
22759   arg4 = (Dali::Property::Type)jarg4;
22760   {
22761     try {
22762       result = (Dali::ChildPropertyRegistration *)new Dali::ChildPropertyRegistration(*arg1,(std::string const &)*arg2,arg3,arg4);
22763     } catch (std::out_of_range& e) {
22764       {
22765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22766       };
22767     } catch (std::exception& e) {
22768       {
22769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22770       };
22771     } catch (Dali::DaliException e) {
22772       {
22773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22774       };
22775     } catch (...) {
22776       {
22777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22778       };
22779     }
22780   }
22781
22782   jresult = (void *)result;
22783
22784   //argout typemap for const std::string&
22785
22786   return jresult;
22787 }
22788
22789
22790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ChildPropertyRegistration(void * jarg1) {
22791   Dali::ChildPropertyRegistration *arg1 = (Dali::ChildPropertyRegistration *) 0 ;
22792
22793   arg1 = (Dali::ChildPropertyRegistration *)jarg1;
22794   {
22795     try {
22796       delete arg1;
22797     } catch (std::out_of_range& e) {
22798       {
22799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
22800       };
22801     } catch (std::exception& e) {
22802       {
22803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
22804       };
22805     } catch (Dali::DaliException e) {
22806       {
22807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
22808       };
22809     } catch (...) {
22810       {
22811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
22812       };
22813     }
22814   }
22815
22816 }
22817
22818
22819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterType(char * jarg1, void * jarg2, void * jarg3) {
22820   unsigned int jresult ;
22821   std::string *arg1 = 0 ;
22822   std::type_info *arg2 = 0 ;
22823   Dali::CSharpTypeInfo::CreateFunction arg3 = (Dali::CSharpTypeInfo::CreateFunction) 0 ;
22824   bool result;
22825
22826   if (!jarg1) {
22827     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22828     return 0;
22829   }
22830   std::string arg1_str(jarg1);
22831   arg1 = &arg1_str;
22832   arg2 = (std::type_info *)jarg2;
22833   if (!arg2) {
22834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::type_info const & type is null", 0);
22835     return 0;
22836   }
22837   arg3 = (Dali::CSharpTypeInfo::CreateFunction)jarg3;
22838   {
22839     try {
22840       result = (bool)Dali::CSharpTypeRegistry::RegisterType((std::string const &)*arg1,(std::type_info const &)*arg2,arg3);
22841     } catch (std::out_of_range& e) {
22842       {
22843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22844       };
22845     } catch (std::exception& e) {
22846       {
22847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22848       };
22849     } catch (Dali::DaliException e) {
22850       {
22851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22852       };
22853     } catch (...) {
22854       {
22855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22856       };
22857     }
22858   }
22859
22860   jresult = result;
22861
22862   //argout typemap for const std::string&
22863
22864   return jresult;
22865 }
22866
22867
22868 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RegisterProperty(char * jarg1, char * jarg2, int jarg3, int jarg4, void * jarg5, void * jarg6) {
22869   unsigned int jresult ;
22870   std::string *arg1 = 0 ;
22871   std::string *arg2 = 0 ;
22872   Dali::Property::Index arg3 ;
22873   Dali::Property::Type arg4 ;
22874   Dali::CSharpTypeInfo::SetPropertyFunction arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction) 0 ;
22875   Dali::CSharpTypeInfo::GetPropertyFunction arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction) 0 ;
22876   bool result;
22877
22878   if (!jarg1) {
22879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22880     return 0;
22881   }
22882   std::string arg1_str(jarg1);
22883   arg1 = &arg1_str;
22884   if (!jarg2) {
22885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
22886     return 0;
22887   }
22888   std::string arg2_str(jarg2);
22889   arg2 = &arg2_str;
22890   arg3 = (Dali::Property::Index)jarg3;
22891   arg4 = (Dali::Property::Type)jarg4;
22892   arg5 = (Dali::CSharpTypeInfo::SetPropertyFunction)jarg5;
22893   arg6 = (Dali::CSharpTypeInfo::GetPropertyFunction)jarg6;
22894   {
22895     try {
22896       result = (bool)Dali::CSharpTypeRegistry::RegisterProperty((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,arg6);
22897     } catch (std::out_of_range& e) {
22898       {
22899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
22900       };
22901     } catch (std::exception& e) {
22902       {
22903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
22904       };
22905     } catch (Dali::DaliException e) {
22906       {
22907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
22908       };
22909     } catch (...) {
22910       {
22911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
22912       };
22913     }
22914   }
22915
22916   jresult = result;
22917
22918   //argout typemap for const std::string&
22919
22920
22921   //argout typemap for const std::string&
22922
22923   return jresult;
22924 }
22925
22926
22927 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginTop_get() {
22928   float jresult ;
22929   float result;
22930
22931   result = (float)(float)Dali::ParentOrigin::TOP;
22932   jresult = result;
22933   return jresult;
22934 }
22935
22936
22937 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginBottom_get() {
22938   float jresult ;
22939   float result;
22940
22941   result = (float)(float)Dali::ParentOrigin::BOTTOM;
22942   jresult = result;
22943   return jresult;
22944 }
22945
22946
22947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginLeft_get() {
22948   float jresult ;
22949   float result;
22950
22951   result = (float)(float)Dali::ParentOrigin::LEFT;
22952   jresult = result;
22953   return jresult;
22954 }
22955
22956
22957 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginRight_get() {
22958   float jresult ;
22959   float result;
22960
22961   result = (float)(float)Dali::ParentOrigin::RIGHT;
22962   jresult = result;
22963   return jresult;
22964 }
22965
22966
22967 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ParentOriginMiddle_get() {
22968   float jresult ;
22969   float result;
22970
22971   result = (float)(float)Dali::ParentOrigin::MIDDLE;
22972   jresult = result;
22973   return jresult;
22974 }
22975
22976
22977 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopLeft_get() {
22978   void * jresult ;
22979   Dali::Vector3 *result = 0 ;
22980
22981   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_LEFT;
22982   jresult = (void *)result;
22983   return jresult;
22984 }
22985
22986
22987 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopCenter_get() {
22988   void * jresult ;
22989   Dali::Vector3 *result = 0 ;
22990
22991   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_CENTER;
22992   jresult = (void *)result;
22993   return jresult;
22994 }
22995
22996
22997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginTopRight_get() {
22998   void * jresult ;
22999   Dali::Vector3 *result = 0 ;
23000
23001   result = (Dali::Vector3 *)&Dali::ParentOrigin::TOP_RIGHT;
23002   jresult = (void *)result;
23003   return jresult;
23004 }
23005
23006
23007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterLeft_get() {
23008   void * jresult ;
23009   Dali::Vector3 *result = 0 ;
23010
23011   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_LEFT;
23012   jresult = (void *)result;
23013   return jresult;
23014 }
23015
23016
23017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenter_get() {
23018   void * jresult ;
23019   Dali::Vector3 *result = 0 ;
23020
23021   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER;
23022   jresult = (void *)result;
23023   return jresult;
23024 }
23025
23026
23027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginCenterRight_get() {
23028   void * jresult ;
23029   Dali::Vector3 *result = 0 ;
23030
23031   result = (Dali::Vector3 *)&Dali::ParentOrigin::CENTER_RIGHT;
23032   jresult = (void *)result;
23033   return jresult;
23034 }
23035
23036
23037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomLeft_get() {
23038   void * jresult ;
23039   Dali::Vector3 *result = 0 ;
23040
23041   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_LEFT;
23042   jresult = (void *)result;
23043   return jresult;
23044 }
23045
23046
23047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomCenter_get() {
23048   void * jresult ;
23049   Dali::Vector3 *result = 0 ;
23050
23051   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_CENTER;
23052   jresult = (void *)result;
23053   return jresult;
23054 }
23055
23056
23057 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ParentOriginBottomRight_get() {
23058   void * jresult ;
23059   Dali::Vector3 *result = 0 ;
23060
23061   result = (Dali::Vector3 *)&Dali::ParentOrigin::BOTTOM_RIGHT;
23062   jresult = (void *)result;
23063   return jresult;
23064 }
23065
23066
23067 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointTop_get() {
23068   float jresult ;
23069   float result;
23070
23071   result = (float)(float)Dali::AnchorPoint::TOP;
23072   jresult = result;
23073   return jresult;
23074 }
23075
23076
23077 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointBottom_get() {
23078   float jresult ;
23079   float result;
23080
23081   result = (float)(float)Dali::AnchorPoint::BOTTOM;
23082   jresult = result;
23083   return jresult;
23084 }
23085
23086
23087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointLeft_get() {
23088   float jresult ;
23089   float result;
23090
23091   result = (float)(float)Dali::AnchorPoint::LEFT;
23092   jresult = result;
23093   return jresult;
23094 }
23095
23096
23097 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointRight_get() {
23098   float jresult ;
23099   float result;
23100
23101   result = (float)(float)Dali::AnchorPoint::RIGHT;
23102   jresult = result;
23103   return jresult;
23104 }
23105
23106
23107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_AnchorPointMiddle_get() {
23108   float jresult ;
23109   float result;
23110
23111   result = (float)(float)Dali::AnchorPoint::MIDDLE;
23112   jresult = result;
23113   return jresult;
23114 }
23115
23116
23117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopLeft_get() {
23118   void * jresult ;
23119   Dali::Vector3 *result = 0 ;
23120
23121   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_LEFT;
23122   jresult = (void *)result;
23123   return jresult;
23124 }
23125
23126
23127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopCenter_get() {
23128   void * jresult ;
23129   Dali::Vector3 *result = 0 ;
23130
23131   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_CENTER;
23132   jresult = (void *)result;
23133   return jresult;
23134 }
23135
23136
23137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointTopRight_get() {
23138   void * jresult ;
23139   Dali::Vector3 *result = 0 ;
23140
23141   result = (Dali::Vector3 *)&Dali::AnchorPoint::TOP_RIGHT;
23142   jresult = (void *)result;
23143   return jresult;
23144 }
23145
23146
23147 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterLeft_get() {
23148   void * jresult ;
23149   Dali::Vector3 *result = 0 ;
23150
23151   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_LEFT;
23152   jresult = (void *)result;
23153   return jresult;
23154 }
23155
23156
23157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenter_get() {
23158   void * jresult ;
23159   Dali::Vector3 *result = 0 ;
23160
23161   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER;
23162   jresult = (void *)result;
23163   return jresult;
23164 }
23165
23166
23167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointCenterRight_get() {
23168   void * jresult ;
23169   Dali::Vector3 *result = 0 ;
23170
23171   result = (Dali::Vector3 *)&Dali::AnchorPoint::CENTER_RIGHT;
23172   jresult = (void *)result;
23173   return jresult;
23174 }
23175
23176
23177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomLeft_get() {
23178   void * jresult ;
23179   Dali::Vector3 *result = 0 ;
23180
23181   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_LEFT;
23182   jresult = (void *)result;
23183   return jresult;
23184 }
23185
23186
23187 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomCenter_get() {
23188   void * jresult ;
23189   Dali::Vector3 *result = 0 ;
23190
23191   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_CENTER;
23192   jresult = (void *)result;
23193   return jresult;
23194 }
23195
23196
23197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AnchorPointBottomRight_get() {
23198   void * jresult ;
23199   Dali::Vector3 *result = 0 ;
23200
23201   result = (Dali::Vector3 *)&Dali::AnchorPoint::BOTTOM_RIGHT;
23202   jresult = (void *)result;
23203   return jresult;
23204 }
23205
23206
23207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLACK_get() {
23208   void * jresult ;
23209   Dali::Vector4 *result = 0 ;
23210
23211   result = (Dali::Vector4 *)&Dali::Color::BLACK;
23212   jresult = (void *)result;
23213   return jresult;
23214 }
23215
23216
23217 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WHITE_get() {
23218   void * jresult ;
23219   Dali::Vector4 *result = 0 ;
23220
23221   result = (Dali::Vector4 *)&Dali::Color::WHITE;
23222   jresult = (void *)result;
23223   return jresult;
23224 }
23225
23226
23227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RED_get() {
23228   void * jresult ;
23229   Dali::Vector4 *result = 0 ;
23230
23231   result = (Dali::Vector4 *)&Dali::Color::RED;
23232   jresult = (void *)result;
23233   return jresult;
23234 }
23235
23236
23237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GREEN_get() {
23238   void * jresult ;
23239   Dali::Vector4 *result = 0 ;
23240
23241   result = (Dali::Vector4 *)&Dali::Color::GREEN;
23242   jresult = (void *)result;
23243   return jresult;
23244 }
23245
23246
23247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_BLUE_get() {
23248   void * jresult ;
23249   Dali::Vector4 *result = 0 ;
23250
23251   result = (Dali::Vector4 *)&Dali::Color::BLUE;
23252   jresult = (void *)result;
23253   return jresult;
23254 }
23255
23256
23257 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_YELLOW_get() {
23258   void * jresult ;
23259   Dali::Vector4 *result = 0 ;
23260
23261   result = (Dali::Vector4 *)&Dali::Color::YELLOW;
23262   jresult = (void *)result;
23263   return jresult;
23264 }
23265
23266
23267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_MAGENTA_get() {
23268   void * jresult ;
23269   Dali::Vector4 *result = 0 ;
23270
23271   result = (Dali::Vector4 *)&Dali::Color::MAGENTA;
23272   jresult = (void *)result;
23273   return jresult;
23274 }
23275
23276
23277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CYAN_get() {
23278   void * jresult ;
23279   Dali::Vector4 *result = 0 ;
23280
23281   result = (Dali::Vector4 *)&Dali::Color::CYAN;
23282   jresult = (void *)result;
23283   return jresult;
23284 }
23285
23286
23287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TRANSPARENT_get() {
23288   void * jresult ;
23289   Dali::Vector4 *result = 0 ;
23290
23291   result = (Dali::Vector4 *)&Dali::Color::TRANSPARENT;
23292   jresult = (void *)result;
23293   return jresult;
23294 }
23295
23296
23297 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_0_get() {
23298   float jresult ;
23299   float result;
23300
23301   result = (float)(float)Dali::Math::MACHINE_EPSILON_0;
23302   jresult = result;
23303   return jresult;
23304 }
23305
23306
23307 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1_get() {
23308   float jresult ;
23309   float result;
23310
23311   result = (float)(float)Dali::Math::MACHINE_EPSILON_1;
23312   jresult = result;
23313   return jresult;
23314 }
23315
23316
23317 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10_get() {
23318   float jresult ;
23319   float result;
23320
23321   result = (float)(float)Dali::Math::MACHINE_EPSILON_10;
23322   jresult = result;
23323   return jresult;
23324 }
23325
23326
23327 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_100_get() {
23328   float jresult ;
23329   float result;
23330
23331   result = (float)(float)Dali::Math::MACHINE_EPSILON_100;
23332   jresult = result;
23333   return jresult;
23334 }
23335
23336
23337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_1000_get() {
23338   float jresult ;
23339   float result;
23340
23341   result = (float)(float)Dali::Math::MACHINE_EPSILON_1000;
23342   jresult = result;
23343   return jresult;
23344 }
23345
23346
23347 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_MACHINE_EPSILON_10000_get() {
23348   float jresult ;
23349   float result;
23350
23351   result = (float)(float)Dali::Math::MACHINE_EPSILON_10000;
23352   jresult = result;
23353   return jresult;
23354 }
23355
23356
23357 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_get() {
23358   float jresult ;
23359   float result;
23360
23361   result = (float)(float)Dali::Math::PI;
23362   jresult = result;
23363   return jresult;
23364 }
23365
23366
23367 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_2_get() {
23368   float jresult ;
23369   float result;
23370
23371   result = (float)(float)Dali::Math::PI_2;
23372   jresult = result;
23373   return jresult;
23374 }
23375
23376
23377 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_4_get() {
23378   float jresult ;
23379   float result;
23380
23381   result = (float)(float)Dali::Math::PI_4;
23382   jresult = result;
23383   return jresult;
23384 }
23385
23386
23387 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PI_OVER_180_get() {
23388   float jresult ;
23389   float result;
23390
23391   result = (float)(float)Dali::Math::PI_OVER_180;
23392   jresult = result;
23393   return jresult;
23394 }
23395
23396
23397 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ONE80_OVER_PI_get() {
23398   float jresult ;
23399   float result;
23400
23401   result = (float)(float)Dali::Math::ONE80_OVER_PI;
23402   jresult = result;
23403   return jresult;
23404 }
23405
23406
23407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ResizePolicyDefault_get() {
23408   int jresult ;
23409   Dali::ResizePolicy::Type result;
23410
23411   result = (Dali::ResizePolicy::Type)(Dali::ResizePolicy::Type)Dali::ResizePolicy::DEFAULT;
23412   jresult = (int)result;
23413   return jresult;
23414 }
23415
23416
23417 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Count(void * jarg1) {
23418   unsigned long jresult ;
23419   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23420   Dali::VectorBase::SizeType result;
23421
23422   arg1 = (Dali::VectorBase *)jarg1;
23423   {
23424     try {
23425       result = ((Dali::VectorBase const *)arg1)->Count();
23426     } catch (std::out_of_range& e) {
23427       {
23428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23429       };
23430     } catch (std::exception& e) {
23431       {
23432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23433       };
23434     } catch (Dali::DaliException e) {
23435       {
23436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23437       };
23438     } catch (...) {
23439       {
23440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23441       };
23442     }
23443   }
23444
23445   jresult = (unsigned long)result;
23446   return jresult;
23447 }
23448
23449
23450 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Size(void * jarg1) {
23451   unsigned long jresult ;
23452   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23453   Dali::VectorBase::SizeType result;
23454
23455   arg1 = (Dali::VectorBase *)jarg1;
23456   {
23457     try {
23458       result = ((Dali::VectorBase const *)arg1)->Size();
23459     } catch (std::out_of_range& e) {
23460       {
23461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23462       };
23463     } catch (std::exception& e) {
23464       {
23465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23466       };
23467     } catch (Dali::DaliException e) {
23468       {
23469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23470       };
23471     } catch (...) {
23472       {
23473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23474       };
23475     }
23476   }
23477
23478   jresult = (unsigned long)result;
23479   return jresult;
23480 }
23481
23482
23483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VectorBase_Empty(void * jarg1) {
23484   unsigned int jresult ;
23485   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23486   bool result;
23487
23488   arg1 = (Dali::VectorBase *)jarg1;
23489   {
23490     try {
23491       result = (bool)((Dali::VectorBase const *)arg1)->Empty();
23492     } catch (std::out_of_range& e) {
23493       {
23494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23495       };
23496     } catch (std::exception& e) {
23497       {
23498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23499       };
23500     } catch (Dali::DaliException e) {
23501       {
23502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23503       };
23504     } catch (...) {
23505       {
23506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23507       };
23508     }
23509   }
23510
23511   jresult = result;
23512   return jresult;
23513 }
23514
23515
23516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VectorBase_Capacity(void * jarg1) {
23517   unsigned long jresult ;
23518   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23519   Dali::VectorBase::SizeType result;
23520
23521   arg1 = (Dali::VectorBase *)jarg1;
23522   {
23523     try {
23524       result = ((Dali::VectorBase const *)arg1)->Capacity();
23525     } catch (std::out_of_range& e) {
23526       {
23527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23528       };
23529     } catch (std::exception& e) {
23530       {
23531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23532       };
23533     } catch (Dali::DaliException e) {
23534       {
23535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23536       };
23537     } catch (...) {
23538       {
23539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23540       };
23541     }
23542   }
23543
23544   jresult = (unsigned long)result;
23545   return jresult;
23546 }
23547
23548
23549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorBase_Release(void * jarg1) {
23550   Dali::VectorBase *arg1 = (Dali::VectorBase *) 0 ;
23551
23552   arg1 = (Dali::VectorBase *)jarg1;
23553   {
23554     try {
23555       (arg1)->Release();
23556     } catch (std::out_of_range& e) {
23557       {
23558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23559       };
23560     } catch (std::exception& e) {
23561       {
23562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23563       };
23564     } catch (Dali::DaliException e) {
23565       {
23566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23567       };
23568     } catch (...) {
23569       {
23570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23571       };
23572     }
23573   }
23574
23575 }
23576
23577
23578 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FIRST_VALID_PIXEL_FORMAT_get() {
23579   int jresult ;
23580   Dali::Pixel::Format result;
23581
23582   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::FIRST_VALID_PIXEL_FORMAT;
23583   jresult = (int)result;
23584   return jresult;
23585 }
23586
23587
23588 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LAST_VALID_PIXEL_FORMAT_get() {
23589   int jresult ;
23590   Dali::Pixel::Format result;
23591
23592   result = (Dali::Pixel::Format)(Dali::Pixel::Format)Dali::Pixel::LAST_VALID_PIXEL_FORMAT;
23593   jresult = (int)result;
23594   return jresult;
23595 }
23596
23597
23598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_HasAlpha(int jarg1) {
23599   unsigned int jresult ;
23600   Dali::Pixel::Format arg1 ;
23601   bool result;
23602
23603   arg1 = (Dali::Pixel::Format)jarg1;
23604   {
23605     try {
23606       result = (bool)Dali::Pixel::HasAlpha(arg1);
23607     } catch (std::out_of_range& e) {
23608       {
23609         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23610       };
23611     } catch (std::exception& e) {
23612       {
23613         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23614       };
23615     } catch (Dali::DaliException e) {
23616       {
23617         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23618       };
23619     } catch (...) {
23620       {
23621         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23622       };
23623     }
23624   }
23625
23626   jresult = result;
23627   return jresult;
23628 }
23629
23630
23631 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GetBytesPerPixel(int jarg1) {
23632   unsigned int jresult ;
23633   Dali::Pixel::Format arg1 ;
23634   unsigned int result;
23635
23636   arg1 = (Dali::Pixel::Format)jarg1;
23637   {
23638     try {
23639       result = (unsigned int)Dali::Pixel::GetBytesPerPixel(arg1);
23640     } catch (std::out_of_range& e) {
23641       {
23642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23643       };
23644     } catch (std::exception& e) {
23645       {
23646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23647       };
23648     } catch (Dali::DaliException e) {
23649       {
23650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23651       };
23652     } catch (...) {
23653       {
23654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23655       };
23656     }
23657   }
23658
23659   jresult = result;
23660   return jresult;
23661 }
23662
23663
23664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GetAlphaOffsetAndMask(int jarg1, void * jarg2, void * jarg3) {
23665   Dali::Pixel::Format arg1 ;
23666   int *arg2 = 0 ;
23667   int *arg3 = 0 ;
23668
23669   arg1 = (Dali::Pixel::Format)jarg1;
23670   arg2 = (int *)jarg2;
23671   if (!arg2) {
23672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23673     return ;
23674   }
23675   arg3 = (int *)jarg3;
23676   if (!arg3) {
23677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "int & type is null", 0);
23678     return ;
23679   }
23680   {
23681     try {
23682       Dali::Pixel::GetAlphaOffsetAndMask(arg1,*arg2,*arg3);
23683     } catch (std::out_of_range& e) {
23684       {
23685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23686       };
23687     } catch (std::exception& e) {
23688       {
23689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23690       };
23691     } catch (Dali::DaliException e) {
23692       {
23693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23694       };
23695     } catch (...) {
23696       {
23697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23698       };
23699     }
23700   }
23701
23702 }
23703
23704
23705 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_New(unsigned char* jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4, int jarg5, int jarg6) {
23706   void * jresult ;
23707   unsigned char *arg1 = (unsigned char *) 0 ;
23708   unsigned int arg2 ;
23709   unsigned int arg3 ;
23710   unsigned int arg4 ;
23711   Dali::Pixel::Format arg5 ;
23712   Dali::PixelData::ReleaseFunction arg6 ;
23713   Dali::PixelData result;
23714
23715   arg1 = jarg1;
23716   arg2 = (unsigned int)jarg2;
23717   arg3 = (unsigned int)jarg3;
23718   arg4 = (unsigned int)jarg4;
23719   arg5 = (Dali::Pixel::Format)jarg5;
23720   arg6 = (Dali::PixelData::ReleaseFunction)jarg6;
23721   {
23722     try {
23723       auto pixelBuffer = new unsigned char[jarg2];
23724       memcpy( pixelBuffer, arg1, arg2);
23725       result = Dali::PixelData::New(pixelBuffer,arg2,arg3,arg4,arg5,arg6);
23726     } catch (std::out_of_range& e) {
23727       {
23728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23729       };
23730     } catch (std::exception& e) {
23731       {
23732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23733       };
23734     } catch (Dali::DaliException e) {
23735       {
23736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23737       };
23738     } catch (...) {
23739       {
23740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23741       };
23742     }
23743   }
23744
23745   jresult = new Dali::PixelData((const Dali::PixelData &)result);
23746
23747
23748   return jresult;
23749 }
23750
23751
23752 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_0() {
23753   void * jresult ;
23754   Dali::PixelData *result = 0 ;
23755
23756   {
23757     try {
23758       result = (Dali::PixelData *)new Dali::PixelData();
23759     } catch (std::out_of_range& e) {
23760       {
23761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23762       };
23763     } catch (std::exception& e) {
23764       {
23765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23766       };
23767     } catch (Dali::DaliException e) {
23768       {
23769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23770       };
23771     } catch (...) {
23772       {
23773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23774       };
23775     }
23776   }
23777
23778   jresult = (void *)result;
23779   return jresult;
23780 }
23781
23782
23783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelData(void * jarg1) {
23784   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23785
23786   arg1 = (Dali::PixelData *)jarg1;
23787   {
23788     try {
23789       delete arg1;
23790     } catch (std::out_of_range& e) {
23791       {
23792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
23793       };
23794     } catch (std::exception& e) {
23795       {
23796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
23797       };
23798     } catch (Dali::DaliException e) {
23799       {
23800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
23801       };
23802     } catch (...) {
23803       {
23804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
23805       };
23806     }
23807   }
23808
23809 }
23810
23811
23812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelData__SWIG_1(void * jarg1) {
23813   void * jresult ;
23814   Dali::PixelData *arg1 = 0 ;
23815   Dali::PixelData *result = 0 ;
23816
23817   arg1 = (Dali::PixelData *)jarg1;
23818   if (!arg1) {
23819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23820     return 0;
23821   }
23822   {
23823     try {
23824       result = (Dali::PixelData *)new Dali::PixelData((Dali::PixelData const &)*arg1);
23825     } catch (std::out_of_range& e) {
23826       {
23827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23828       };
23829     } catch (std::exception& e) {
23830       {
23831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23832       };
23833     } catch (Dali::DaliException e) {
23834       {
23835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23836       };
23837     } catch (...) {
23838       {
23839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23840       };
23841     }
23842   }
23843
23844   jresult = (void *)result;
23845   return jresult;
23846 }
23847
23848
23849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelData_Assign(void * jarg1, void * jarg2) {
23850   void * jresult ;
23851   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23852   Dali::PixelData *arg2 = 0 ;
23853   Dali::PixelData *result = 0 ;
23854
23855   arg1 = (Dali::PixelData *)jarg1;
23856   arg2 = (Dali::PixelData *)jarg2;
23857   if (!arg2) {
23858     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PixelData const & type is null", 0);
23859     return 0;
23860   }
23861   {
23862     try {
23863       result = (Dali::PixelData *) &(arg1)->operator =((Dali::PixelData const &)*arg2);
23864     } catch (std::out_of_range& e) {
23865       {
23866         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23867       };
23868     } catch (std::exception& e) {
23869       {
23870         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23871       };
23872     } catch (Dali::DaliException e) {
23873       {
23874         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23875       };
23876     } catch (...) {
23877       {
23878         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23879       };
23880     }
23881   }
23882
23883   jresult = (void *)result;
23884   return jresult;
23885 }
23886
23887
23888 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetWidth(void * jarg1) {
23889   unsigned int jresult ;
23890   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23891   unsigned int result;
23892
23893   arg1 = (Dali::PixelData *)jarg1;
23894   {
23895     try {
23896       result = (unsigned int)((Dali::PixelData const *)arg1)->GetWidth();
23897     } catch (std::out_of_range& e) {
23898       {
23899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23900       };
23901     } catch (std::exception& e) {
23902       {
23903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23904       };
23905     } catch (Dali::DaliException e) {
23906       {
23907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23908       };
23909     } catch (...) {
23910       {
23911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23912       };
23913     }
23914   }
23915
23916   jresult = result;
23917   return jresult;
23918 }
23919
23920
23921 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelData_GetHeight(void * jarg1) {
23922   unsigned int jresult ;
23923   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23924   unsigned int result;
23925
23926   arg1 = (Dali::PixelData *)jarg1;
23927   {
23928     try {
23929       result = (unsigned int)((Dali::PixelData const *)arg1)->GetHeight();
23930     } catch (std::out_of_range& e) {
23931       {
23932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23933       };
23934     } catch (std::exception& e) {
23935       {
23936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23937       };
23938     } catch (Dali::DaliException e) {
23939       {
23940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23941       };
23942     } catch (...) {
23943       {
23944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23945       };
23946     }
23947   }
23948
23949   jresult = result;
23950   return jresult;
23951 }
23952
23953
23954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelData_GetPixelFormat(void * jarg1) {
23955   int jresult ;
23956   Dali::PixelData *arg1 = (Dali::PixelData *) 0 ;
23957   Dali::Pixel::Format result;
23958
23959   arg1 = (Dali::PixelData *)jarg1;
23960   {
23961     try {
23962       result = (Dali::Pixel::Format)((Dali::PixelData const *)arg1)->GetPixelFormat();
23963     } catch (std::out_of_range& e) {
23964       {
23965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
23966       };
23967     } catch (std::exception& e) {
23968       {
23969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
23970       };
23971     } catch (Dali::DaliException e) {
23972       {
23973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
23974       };
23975     } catch (...) {
23976       {
23977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
23978       };
23979     }
23980   }
23981
23982   jresult = (int)result;
23983   return jresult;
23984 }
23985
23986
23987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_X_get() {
23988   unsigned int jresult ;
23989   unsigned int result;
23990
23991   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_X;
23992   jresult = result;
23993   return jresult;
23994 }
23995
23996
23997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_X_get() {
23998   unsigned int jresult ;
23999   unsigned int result;
24000
24001   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_X;
24002   jresult = result;
24003   return jresult;
24004 }
24005
24006
24007 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Y_get() {
24008   unsigned int jresult ;
24009   unsigned int result;
24010
24011   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Y;
24012   jresult = result;
24013   return jresult;
24014 }
24015
24016
24017 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Y_get() {
24018   unsigned int jresult ;
24019   unsigned int result;
24020
24021   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Y;
24022   jresult = result;
24023   return jresult;
24024 }
24025
24026
24027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_POSITIVE_Z_get() {
24028   unsigned int jresult ;
24029   unsigned int result;
24030
24031   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::POSITIVE_Z;
24032   jresult = result;
24033   return jresult;
24034 }
24035
24036
24037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NEGATIVE_Z_get() {
24038   unsigned int jresult ;
24039   unsigned int result;
24040
24041   result = (unsigned int)(unsigned int)Dali::CubeMapLayer::NEGATIVE_Z;
24042   jresult = result;
24043   return jresult;
24044 }
24045
24046
24047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_0(int jarg1, int jarg2, unsigned int jarg3, unsigned int jarg4) {
24048   void * jresult ;
24049   Dali::TextureType::Type arg1 ;
24050   Dali::Pixel::Format arg2 ;
24051   unsigned int arg3 ;
24052   unsigned int arg4 ;
24053   Dali::Texture result;
24054
24055   arg1 = (Dali::TextureType::Type)jarg1;
24056   arg2 = (Dali::Pixel::Format)jarg2;
24057   arg3 = (unsigned int)jarg3;
24058   arg4 = (unsigned int)jarg4;
24059   {
24060     try {
24061       result = Dali::Texture::New(arg1,arg2,arg3,arg4);
24062     } catch (std::out_of_range& e) {
24063       {
24064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24065       };
24066     } catch (std::exception& e) {
24067       {
24068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24069       };
24070     } catch (Dali::DaliException e) {
24071       {
24072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24073       };
24074     } catch (...) {
24075       {
24076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24077       };
24078     }
24079   }
24080
24081   jresult = new Dali::Texture((const Dali::Texture &)result);
24082   return jresult;
24083 }
24084
24085
24086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_New__SWIG_1(void * jarg1) {
24087   void * jresult ;
24088   NativeImageInterface *arg1 = 0 ;
24089   Dali::Texture result;
24090
24091   arg1 = (NativeImageInterface *)jarg1;
24092   if (!arg1) {
24093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "NativeImageInterface & type is null", 0);
24094     return 0;
24095   }
24096   {
24097     try {
24098       result = Dali::Texture::New(*arg1);
24099     } catch (std::out_of_range& e) {
24100       {
24101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24102       };
24103     } catch (std::exception& e) {
24104       {
24105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24106       };
24107     } catch (Dali::DaliException e) {
24108       {
24109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24110       };
24111     } catch (...) {
24112       {
24113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24114       };
24115     }
24116   }
24117
24118   jresult = new Dali::Texture((const Dali::Texture &)result);
24119   return jresult;
24120 }
24121
24122
24123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_0() {
24124   void * jresult ;
24125   Dali::Texture *result = 0 ;
24126
24127   {
24128     try {
24129       result = (Dali::Texture *)new Dali::Texture();
24130     } catch (std::out_of_range& e) {
24131       {
24132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24133       };
24134     } catch (std::exception& e) {
24135       {
24136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24137       };
24138     } catch (Dali::DaliException e) {
24139       {
24140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24141       };
24142     } catch (...) {
24143       {
24144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24145       };
24146     }
24147   }
24148
24149   jresult = (void *)result;
24150   return jresult;
24151 }
24152
24153
24154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Texture(void * jarg1) {
24155   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24156
24157   arg1 = (Dali::Texture *)jarg1;
24158   {
24159     try {
24160       delete arg1;
24161     } catch (std::out_of_range& e) {
24162       {
24163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24164       };
24165     } catch (std::exception& e) {
24166       {
24167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24168       };
24169     } catch (Dali::DaliException e) {
24170       {
24171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24172       };
24173     } catch (...) {
24174       {
24175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24176       };
24177     }
24178   }
24179
24180 }
24181
24182
24183 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Texture__SWIG_1(void * jarg1) {
24184   void * jresult ;
24185   Dali::Texture *arg1 = 0 ;
24186   Dali::Texture *result = 0 ;
24187
24188   arg1 = (Dali::Texture *)jarg1;
24189   if (!arg1) {
24190     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24191     return 0;
24192   }
24193   {
24194     try {
24195       result = (Dali::Texture *)new Dali::Texture((Dali::Texture const &)*arg1);
24196     } catch (std::out_of_range& e) {
24197       {
24198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24199       };
24200     } catch (std::exception& e) {
24201       {
24202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24203       };
24204     } catch (Dali::DaliException e) {
24205       {
24206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24207       };
24208     } catch (...) {
24209       {
24210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24211       };
24212     }
24213   }
24214
24215   jresult = (void *)result;
24216   return jresult;
24217 }
24218
24219
24220 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_DownCast(void * jarg1) {
24221   void * jresult ;
24222   Dali::BaseHandle arg1 ;
24223   Dali::BaseHandle *argp1 ;
24224   Dali::Texture result;
24225
24226   argp1 = (Dali::BaseHandle *)jarg1;
24227   if (!argp1) {
24228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24229     return 0;
24230   }
24231   arg1 = *argp1;
24232   {
24233     try {
24234       result = Dali::Texture::DownCast(arg1);
24235     } catch (std::out_of_range& e) {
24236       {
24237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24238       };
24239     } catch (std::exception& e) {
24240       {
24241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24242       };
24243     } catch (Dali::DaliException e) {
24244       {
24245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24246       };
24247     } catch (...) {
24248       {
24249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24250       };
24251     }
24252   }
24253
24254   jresult = new Dali::Texture((const Dali::Texture &)result);
24255   return jresult;
24256 }
24257
24258
24259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Texture_Assign(void * jarg1, void * jarg2) {
24260   void * jresult ;
24261   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24262   Dali::Texture *arg2 = 0 ;
24263   Dali::Texture *result = 0 ;
24264
24265   arg1 = (Dali::Texture *)jarg1;
24266   arg2 = (Dali::Texture *)jarg2;
24267   if (!arg2) {
24268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture const & type is null", 0);
24269     return 0;
24270   }
24271   {
24272     try {
24273       result = (Dali::Texture *) &(arg1)->operator =((Dali::Texture const &)*arg2);
24274     } catch (std::out_of_range& e) {
24275       {
24276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24277       };
24278     } catch (std::exception& e) {
24279       {
24280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24281       };
24282     } catch (Dali::DaliException e) {
24283       {
24284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24285       };
24286     } catch (...) {
24287       {
24288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24289       };
24290     }
24291   }
24292
24293   jresult = (void *)result;
24294   return jresult;
24295 }
24296
24297
24298 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_Upload__SWIG_0(void * jarg1, void * jarg2) {
24299   unsigned int jresult ;
24300   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24301   Dali::PixelData arg2 ;
24302   Dali::PixelData *argp2 ;
24303   bool result;
24304
24305   arg1 = (Dali::Texture *)jarg1;
24306   argp2 = (Dali::PixelData *)jarg2;
24307   if (!argp2) {
24308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24309     return 0;
24310   }
24311   arg2 = *argp2;
24312   {
24313     try {
24314       result = (bool)(arg1)->Upload(arg2);
24315     } catch (std::out_of_range& e) {
24316       {
24317         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24318       };
24319     } catch (std::exception& e) {
24320       {
24321         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24322       };
24323     } catch (Dali::DaliException e) {
24324       {
24325         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24326       };
24327     } catch (...) {
24328       {
24329         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24330       };
24331     }
24332   }
24333
24334   jresult = result;
24335   return jresult;
24336 }
24337
24338
24339 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) {
24340   unsigned int jresult ;
24341   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24342   Dali::PixelData arg2 ;
24343   unsigned int arg3 ;
24344   unsigned int arg4 ;
24345   unsigned int arg5 ;
24346   unsigned int arg6 ;
24347   unsigned int arg7 ;
24348   unsigned int arg8 ;
24349   Dali::PixelData *argp2 ;
24350   bool result;
24351
24352   arg1 = (Dali::Texture *)jarg1;
24353   argp2 = (Dali::PixelData *)jarg2;
24354   if (!argp2) {
24355     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PixelData", 0);
24356     return 0;
24357   }
24358   arg2 = *argp2;
24359   arg3 = (unsigned int)jarg3;
24360   arg4 = (unsigned int)jarg4;
24361   arg5 = (unsigned int)jarg5;
24362   arg6 = (unsigned int)jarg6;
24363   arg7 = (unsigned int)jarg7;
24364   arg8 = (unsigned int)jarg8;
24365   {
24366     try {
24367       result = (bool)(arg1)->Upload(arg2,arg3,arg4,arg5,arg6,arg7,arg8);
24368     } catch (std::out_of_range& e) {
24369       {
24370         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24371       };
24372     } catch (std::exception& e) {
24373       {
24374         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24375       };
24376     } catch (Dali::DaliException e) {
24377       {
24378         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24379       };
24380     } catch (...) {
24381       {
24382         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24383       };
24384     }
24385   }
24386
24387   jresult = result;
24388   return jresult;
24389 }
24390
24391
24392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Texture_GenerateMipmaps(void * jarg1) {
24393   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24394
24395   arg1 = (Dali::Texture *)jarg1;
24396   {
24397     try {
24398       (arg1)->GenerateMipmaps();
24399     } catch (std::out_of_range& e) {
24400       {
24401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24402       };
24403     } catch (std::exception& e) {
24404       {
24405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24406       };
24407     } catch (Dali::DaliException e) {
24408       {
24409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24410       };
24411     } catch (...) {
24412       {
24413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24414       };
24415     }
24416   }
24417
24418 }
24419
24420
24421 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetWidth(void * jarg1) {
24422   unsigned int jresult ;
24423   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24424   unsigned int result;
24425
24426   arg1 = (Dali::Texture *)jarg1;
24427   {
24428     try {
24429       result = (unsigned int)((Dali::Texture const *)arg1)->GetWidth();
24430     } catch (std::out_of_range& e) {
24431       {
24432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24433       };
24434     } catch (std::exception& e) {
24435       {
24436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24437       };
24438     } catch (Dali::DaliException e) {
24439       {
24440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24441       };
24442     } catch (...) {
24443       {
24444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24445       };
24446     }
24447   }
24448
24449   jresult = result;
24450   return jresult;
24451 }
24452
24453
24454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Texture_GetHeight(void * jarg1) {
24455   unsigned int jresult ;
24456   Dali::Texture *arg1 = (Dali::Texture *) 0 ;
24457   unsigned int result;
24458
24459   arg1 = (Dali::Texture *)jarg1;
24460   {
24461     try {
24462       result = (unsigned int)((Dali::Texture const *)arg1)->GetHeight();
24463     } catch (std::out_of_range& e) {
24464       {
24465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24466       };
24467     } catch (std::exception& e) {
24468       {
24469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24470       };
24471     } catch (Dali::DaliException e) {
24472       {
24473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24474       };
24475     } catch (...) {
24476       {
24477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24478       };
24479     }
24480   }
24481
24482   jresult = result;
24483   return jresult;
24484 }
24485
24486
24487 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_New() {
24488   void * jresult ;
24489   Dali::Sampler result;
24490
24491   {
24492     try {
24493       result = Dali::Sampler::New();
24494     } catch (std::out_of_range& e) {
24495       {
24496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24497       };
24498     } catch (std::exception& e) {
24499       {
24500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24501       };
24502     } catch (Dali::DaliException e) {
24503       {
24504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24505       };
24506     } catch (...) {
24507       {
24508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24509       };
24510     }
24511   }
24512
24513   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24514   return jresult;
24515 }
24516
24517
24518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_0() {
24519   void * jresult ;
24520   Dali::Sampler *result = 0 ;
24521
24522   {
24523     try {
24524       result = (Dali::Sampler *)new Dali::Sampler();
24525     } catch (std::out_of_range& e) {
24526       {
24527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24528       };
24529     } catch (std::exception& e) {
24530       {
24531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24532       };
24533     } catch (Dali::DaliException e) {
24534       {
24535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24536       };
24537     } catch (...) {
24538       {
24539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24540       };
24541     }
24542   }
24543
24544   jresult = (void *)result;
24545   return jresult;
24546 }
24547
24548
24549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Sampler(void * jarg1) {
24550   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24551
24552   arg1 = (Dali::Sampler *)jarg1;
24553   {
24554     try {
24555       delete arg1;
24556     } catch (std::out_of_range& e) {
24557       {
24558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24559       };
24560     } catch (std::exception& e) {
24561       {
24562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24563       };
24564     } catch (Dali::DaliException e) {
24565       {
24566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24567       };
24568     } catch (...) {
24569       {
24570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24571       };
24572     }
24573   }
24574
24575 }
24576
24577
24578 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Sampler__SWIG_1(void * jarg1) {
24579   void * jresult ;
24580   Dali::Sampler *arg1 = 0 ;
24581   Dali::Sampler *result = 0 ;
24582
24583   arg1 = (Dali::Sampler *)jarg1;
24584   if (!arg1) {
24585     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24586     return 0;
24587   }
24588   {
24589     try {
24590       result = (Dali::Sampler *)new Dali::Sampler((Dali::Sampler const &)*arg1);
24591     } catch (std::out_of_range& e) {
24592       {
24593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24594       };
24595     } catch (std::exception& e) {
24596       {
24597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24598       };
24599     } catch (Dali::DaliException e) {
24600       {
24601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24602       };
24603     } catch (...) {
24604       {
24605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24606       };
24607     }
24608   }
24609
24610   jresult = (void *)result;
24611   return jresult;
24612 }
24613
24614
24615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_DownCast(void * jarg1) {
24616   void * jresult ;
24617   Dali::BaseHandle arg1 ;
24618   Dali::BaseHandle *argp1 ;
24619   Dali::Sampler result;
24620
24621   argp1 = (Dali::BaseHandle *)jarg1;
24622   if (!argp1) {
24623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24624     return 0;
24625   }
24626   arg1 = *argp1;
24627   {
24628     try {
24629       result = Dali::Sampler::DownCast(arg1);
24630     } catch (std::out_of_range& e) {
24631       {
24632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24633       };
24634     } catch (std::exception& e) {
24635       {
24636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24637       };
24638     } catch (Dali::DaliException e) {
24639       {
24640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24641       };
24642     } catch (...) {
24643       {
24644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24645       };
24646     }
24647   }
24648
24649   jresult = new Dali::Sampler((const Dali::Sampler &)result);
24650   return jresult;
24651 }
24652
24653
24654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Sampler_Assign(void * jarg1, void * jarg2) {
24655   void * jresult ;
24656   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24657   Dali::Sampler *arg2 = 0 ;
24658   Dali::Sampler *result = 0 ;
24659
24660   arg1 = (Dali::Sampler *)jarg1;
24661   arg2 = (Dali::Sampler *)jarg2;
24662   if (!arg2) {
24663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Sampler const & type is null", 0);
24664     return 0;
24665   }
24666   {
24667     try {
24668       result = (Dali::Sampler *) &(arg1)->operator =((Dali::Sampler const &)*arg2);
24669     } catch (std::out_of_range& e) {
24670       {
24671         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24672       };
24673     } catch (std::exception& e) {
24674       {
24675         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24676       };
24677     } catch (Dali::DaliException e) {
24678       {
24679         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24680       };
24681     } catch (...) {
24682       {
24683         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24684       };
24685     }
24686   }
24687
24688   jresult = (void *)result;
24689   return jresult;
24690 }
24691
24692
24693 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetFilterMode(void * jarg1, int jarg2, int jarg3) {
24694   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24695   Dali::FilterMode::Type arg2 ;
24696   Dali::FilterMode::Type arg3 ;
24697
24698   arg1 = (Dali::Sampler *)jarg1;
24699   arg2 = (Dali::FilterMode::Type)jarg2;
24700   arg3 = (Dali::FilterMode::Type)jarg3;
24701   {
24702     try {
24703       (arg1)->SetFilterMode(arg2,arg3);
24704     } catch (std::out_of_range& e) {
24705       {
24706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24707       };
24708     } catch (std::exception& e) {
24709       {
24710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24711       };
24712     } catch (Dali::DaliException e) {
24713       {
24714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24715       };
24716     } catch (...) {
24717       {
24718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24719       };
24720     }
24721   }
24722
24723 }
24724
24725
24726 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_0(void * jarg1, int jarg2, int jarg3) {
24727   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24728   Dali::WrapMode::Type arg2 ;
24729   Dali::WrapMode::Type arg3 ;
24730
24731   arg1 = (Dali::Sampler *)jarg1;
24732   arg2 = (Dali::WrapMode::Type)jarg2;
24733   arg3 = (Dali::WrapMode::Type)jarg3;
24734   {
24735     try {
24736       (arg1)->SetWrapMode(arg2,arg3);
24737     } catch (std::out_of_range& e) {
24738       {
24739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24740       };
24741     } catch (std::exception& e) {
24742       {
24743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24744       };
24745     } catch (Dali::DaliException e) {
24746       {
24747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24748       };
24749     } catch (...) {
24750       {
24751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24752       };
24753     }
24754   }
24755
24756 }
24757
24758
24759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Sampler_SetWrapMode__SWIG_1(void * jarg1, int jarg2, int jarg3, int jarg4) {
24760   Dali::Sampler *arg1 = (Dali::Sampler *) 0 ;
24761   Dali::WrapMode::Type arg2 ;
24762   Dali::WrapMode::Type arg3 ;
24763   Dali::WrapMode::Type arg4 ;
24764
24765   arg1 = (Dali::Sampler *)jarg1;
24766   arg2 = (Dali::WrapMode::Type)jarg2;
24767   arg3 = (Dali::WrapMode::Type)jarg3;
24768   arg4 = (Dali::WrapMode::Type)jarg4;
24769   {
24770     try {
24771       (arg1)->SetWrapMode(arg2,arg3,arg4);
24772     } catch (std::out_of_range& e) {
24773       {
24774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24775       };
24776     } catch (std::exception& e) {
24777       {
24778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24779       };
24780     } catch (Dali::DaliException e) {
24781       {
24782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24783       };
24784     } catch (...) {
24785       {
24786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24787       };
24788     }
24789   }
24790
24791 }
24792
24793
24794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_New() {
24795   void * jresult ;
24796   Dali::TextureSet result;
24797
24798   {
24799     try {
24800       result = Dali::TextureSet::New();
24801     } catch (std::out_of_range& e) {
24802       {
24803         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24804       };
24805     } catch (std::exception& e) {
24806       {
24807         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24808       };
24809     } catch (Dali::DaliException e) {
24810       {
24811         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24812       };
24813     } catch (...) {
24814       {
24815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24816       };
24817     }
24818   }
24819
24820   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24821   return jresult;
24822 }
24823
24824
24825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_0() {
24826   void * jresult ;
24827   Dali::TextureSet *result = 0 ;
24828
24829   {
24830     try {
24831       result = (Dali::TextureSet *)new Dali::TextureSet();
24832     } catch (std::out_of_range& e) {
24833       {
24834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24835       };
24836     } catch (std::exception& e) {
24837       {
24838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24839       };
24840     } catch (Dali::DaliException e) {
24841       {
24842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24843       };
24844     } catch (...) {
24845       {
24846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24847       };
24848     }
24849   }
24850
24851   jresult = (void *)result;
24852   return jresult;
24853 }
24854
24855
24856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextureSet(void * jarg1) {
24857   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24858
24859   arg1 = (Dali::TextureSet *)jarg1;
24860   {
24861     try {
24862       delete arg1;
24863     } catch (std::out_of_range& e) {
24864       {
24865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
24866       };
24867     } catch (std::exception& e) {
24868       {
24869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
24870       };
24871     } catch (Dali::DaliException e) {
24872       {
24873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
24874       };
24875     } catch (...) {
24876       {
24877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
24878       };
24879     }
24880   }
24881
24882 }
24883
24884
24885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextureSet__SWIG_1(void * jarg1) {
24886   void * jresult ;
24887   Dali::TextureSet *arg1 = 0 ;
24888   Dali::TextureSet *result = 0 ;
24889
24890   arg1 = (Dali::TextureSet *)jarg1;
24891   if (!arg1) {
24892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24893     return 0;
24894   }
24895   {
24896     try {
24897       result = (Dali::TextureSet *)new Dali::TextureSet((Dali::TextureSet const &)*arg1);
24898     } catch (std::out_of_range& e) {
24899       {
24900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24901       };
24902     } catch (std::exception& e) {
24903       {
24904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24905       };
24906     } catch (Dali::DaliException e) {
24907       {
24908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24909       };
24910     } catch (...) {
24911       {
24912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24913       };
24914     }
24915   }
24916
24917   jresult = (void *)result;
24918   return jresult;
24919 }
24920
24921
24922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_DownCast(void * jarg1) {
24923   void * jresult ;
24924   Dali::BaseHandle arg1 ;
24925   Dali::BaseHandle *argp1 ;
24926   Dali::TextureSet result;
24927
24928   argp1 = (Dali::BaseHandle *)jarg1;
24929   if (!argp1) {
24930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
24931     return 0;
24932   }
24933   arg1 = *argp1;
24934   {
24935     try {
24936       result = Dali::TextureSet::DownCast(arg1);
24937     } catch (std::out_of_range& e) {
24938       {
24939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24940       };
24941     } catch (std::exception& e) {
24942       {
24943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24944       };
24945     } catch (Dali::DaliException e) {
24946       {
24947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24948       };
24949     } catch (...) {
24950       {
24951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24952       };
24953     }
24954   }
24955
24956   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
24957   return jresult;
24958 }
24959
24960
24961 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_Assign(void * jarg1, void * jarg2) {
24962   void * jresult ;
24963   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
24964   Dali::TextureSet *arg2 = 0 ;
24965   Dali::TextureSet *result = 0 ;
24966
24967   arg1 = (Dali::TextureSet *)jarg1;
24968   arg2 = (Dali::TextureSet *)jarg2;
24969   if (!arg2) {
24970     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet const & type is null", 0);
24971     return 0;
24972   }
24973   {
24974     try {
24975       result = (Dali::TextureSet *) &(arg1)->operator =((Dali::TextureSet const &)*arg2);
24976     } catch (std::out_of_range& e) {
24977       {
24978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
24979       };
24980     } catch (std::exception& e) {
24981       {
24982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
24983       };
24984     } catch (Dali::DaliException e) {
24985       {
24986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
24987       };
24988     } catch (...) {
24989       {
24990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
24991       };
24992     }
24993   }
24994
24995   jresult = (void *)result;
24996   return jresult;
24997 }
24998
24999
25000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetTexture(void * jarg1, unsigned long jarg2, void * jarg3) {
25001   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25002   size_t arg2 ;
25003   Dali::Texture arg3 ;
25004   Dali::Texture *argp3 ;
25005
25006   arg1 = (Dali::TextureSet *)jarg1;
25007   arg2 = (size_t)jarg2;
25008   argp3 = (Dali::Texture *)jarg3;
25009   if (!argp3) {
25010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
25011     return ;
25012   }
25013   arg3 = *argp3;
25014   {
25015     try {
25016       (arg1)->SetTexture(arg2,arg3);
25017     } catch (std::out_of_range& e) {
25018       {
25019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25020       };
25021     } catch (std::exception& e) {
25022       {
25023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25024       };
25025     } catch (Dali::DaliException e) {
25026       {
25027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25028       };
25029     } catch (...) {
25030       {
25031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25032       };
25033     }
25034   }
25035
25036 }
25037
25038
25039 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetTexture(void * jarg1, unsigned long jarg2) {
25040   void * jresult ;
25041   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25042   size_t arg2 ;
25043   Dali::Texture result;
25044
25045   arg1 = (Dali::TextureSet *)jarg1;
25046   arg2 = (size_t)jarg2;
25047   {
25048     try {
25049       result = ((Dali::TextureSet const *)arg1)->GetTexture(arg2);
25050     } catch (std::out_of_range& e) {
25051       {
25052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25053       };
25054     } catch (std::exception& e) {
25055       {
25056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25057       };
25058     } catch (Dali::DaliException e) {
25059       {
25060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25061       };
25062     } catch (...) {
25063       {
25064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25065       };
25066     }
25067   }
25068
25069   jresult = new Dali::Texture((const Dali::Texture &)result);
25070   return jresult;
25071 }
25072
25073
25074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TextureSet_SetSampler(void * jarg1, unsigned long jarg2, void * jarg3) {
25075   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25076   size_t arg2 ;
25077   Dali::Sampler arg3 ;
25078   Dali::Sampler *argp3 ;
25079
25080   arg1 = (Dali::TextureSet *)jarg1;
25081   arg2 = (size_t)jarg2;
25082   argp3 = (Dali::Sampler *)jarg3;
25083   if (!argp3) {
25084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Sampler", 0);
25085     return ;
25086   }
25087   arg3 = *argp3;
25088   {
25089     try {
25090       (arg1)->SetSampler(arg2,arg3);
25091     } catch (std::out_of_range& e) {
25092       {
25093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25094       };
25095     } catch (std::exception& e) {
25096       {
25097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25098       };
25099     } catch (Dali::DaliException e) {
25100       {
25101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25102       };
25103     } catch (...) {
25104       {
25105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25106       };
25107     }
25108   }
25109
25110 }
25111
25112
25113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextureSet_GetSampler(void * jarg1, unsigned long jarg2) {
25114   void * jresult ;
25115   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25116   size_t arg2 ;
25117   Dali::Sampler result;
25118
25119   arg1 = (Dali::TextureSet *)jarg1;
25120   arg2 = (size_t)jarg2;
25121   {
25122     try {
25123       result = ((Dali::TextureSet const *)arg1)->GetSampler(arg2);
25124     } catch (std::out_of_range& e) {
25125       {
25126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25127       };
25128     } catch (std::exception& e) {
25129       {
25130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25131       };
25132     } catch (Dali::DaliException e) {
25133       {
25134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25135       };
25136     } catch (...) {
25137       {
25138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25139       };
25140     }
25141   }
25142
25143   jresult = new Dali::Sampler((const Dali::Sampler &)result);
25144   return jresult;
25145 }
25146
25147
25148 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TextureSet_GetTextureCount(void * jarg1) {
25149   unsigned long jresult ;
25150   Dali::TextureSet *arg1 = (Dali::TextureSet *) 0 ;
25151   size_t result;
25152
25153   arg1 = (Dali::TextureSet *)jarg1;
25154   {
25155     try {
25156       result = ((Dali::TextureSet const *)arg1)->GetTextureCount();
25157     } catch (std::out_of_range& e) {
25158       {
25159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25160       };
25161     } catch (std::exception& e) {
25162       {
25163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25164       };
25165     } catch (Dali::DaliException e) {
25166       {
25167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25168       };
25169     } catch (...) {
25170       {
25171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25172       };
25173     }
25174   }
25175
25176   jresult = (unsigned long)result;
25177   return jresult;
25178 }
25179
25180
25181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_New(void * jarg1) {
25182   void * jresult ;
25183   Dali::Property::Map *arg1 = 0 ;
25184   Dali::PropertyBuffer result;
25185
25186   arg1 = (Dali::Property::Map *)jarg1;
25187   if (!arg1) {
25188     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
25189     return 0;
25190   }
25191   {
25192     try {
25193       result = Dali::PropertyBuffer::New(*arg1);
25194     } catch (std::out_of_range& e) {
25195       {
25196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25197       };
25198     } catch (std::exception& e) {
25199       {
25200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25201       };
25202     } catch (Dali::DaliException e) {
25203       {
25204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25205       };
25206     } catch (...) {
25207       {
25208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25209       };
25210     }
25211   }
25212
25213   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25214   return jresult;
25215 }
25216
25217
25218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_0() {
25219   void * jresult ;
25220   Dali::PropertyBuffer *result = 0 ;
25221
25222   {
25223     try {
25224       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer();
25225     } catch (std::out_of_range& e) {
25226       {
25227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25228       };
25229     } catch (std::exception& e) {
25230       {
25231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25232       };
25233     } catch (Dali::DaliException e) {
25234       {
25235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25236       };
25237     } catch (...) {
25238       {
25239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25240       };
25241     }
25242   }
25243
25244   jresult = (void *)result;
25245   return jresult;
25246 }
25247
25248
25249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyBuffer(void * jarg1) {
25250   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25251
25252   arg1 = (Dali::PropertyBuffer *)jarg1;
25253   {
25254     try {
25255       delete arg1;
25256     } catch (std::out_of_range& e) {
25257       {
25258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25259       };
25260     } catch (std::exception& e) {
25261       {
25262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25263       };
25264     } catch (Dali::DaliException e) {
25265       {
25266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25267       };
25268     } catch (...) {
25269       {
25270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25271       };
25272     }
25273   }
25274
25275 }
25276
25277
25278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyBuffer__SWIG_1(void * jarg1) {
25279   void * jresult ;
25280   Dali::PropertyBuffer *arg1 = 0 ;
25281   Dali::PropertyBuffer *result = 0 ;
25282
25283   arg1 = (Dali::PropertyBuffer *)jarg1;
25284   if (!arg1) {
25285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25286     return 0;
25287   }
25288   {
25289     try {
25290       result = (Dali::PropertyBuffer *)new Dali::PropertyBuffer((Dali::PropertyBuffer const &)*arg1);
25291     } catch (std::out_of_range& e) {
25292       {
25293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25294       };
25295     } catch (std::exception& e) {
25296       {
25297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25298       };
25299     } catch (Dali::DaliException e) {
25300       {
25301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25302       };
25303     } catch (...) {
25304       {
25305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25306       };
25307     }
25308   }
25309
25310   jresult = (void *)result;
25311   return jresult;
25312 }
25313
25314
25315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_DownCast(void * jarg1) {
25316   void * jresult ;
25317   Dali::BaseHandle arg1 ;
25318   Dali::BaseHandle *argp1 ;
25319   Dali::PropertyBuffer result;
25320
25321   argp1 = (Dali::BaseHandle *)jarg1;
25322   if (!argp1) {
25323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25324     return 0;
25325   }
25326   arg1 = *argp1;
25327   {
25328     try {
25329       result = Dali::PropertyBuffer::DownCast(arg1);
25330     } catch (std::out_of_range& e) {
25331       {
25332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25333       };
25334     } catch (std::exception& e) {
25335       {
25336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25337       };
25338     } catch (Dali::DaliException e) {
25339       {
25340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25341       };
25342     } catch (...) {
25343       {
25344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25345       };
25346     }
25347   }
25348
25349   jresult = new Dali::PropertyBuffer((const Dali::PropertyBuffer &)result);
25350   return jresult;
25351 }
25352
25353
25354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PropertyBuffer_Assign(void * jarg1, void * jarg2) {
25355   void * jresult ;
25356   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25357   Dali::PropertyBuffer *arg2 = 0 ;
25358   Dali::PropertyBuffer *result = 0 ;
25359
25360   arg1 = (Dali::PropertyBuffer *)jarg1;
25361   arg2 = (Dali::PropertyBuffer *)jarg2;
25362   if (!arg2) {
25363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer const & type is null", 0);
25364     return 0;
25365   }
25366   {
25367     try {
25368       result = (Dali::PropertyBuffer *) &(arg1)->operator =((Dali::PropertyBuffer const &)*arg2);
25369     } catch (std::out_of_range& e) {
25370       {
25371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25372       };
25373     } catch (std::exception& e) {
25374       {
25375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25376       };
25377     } catch (Dali::DaliException e) {
25378       {
25379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25380       };
25381     } catch (...) {
25382       {
25383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25384       };
25385     }
25386   }
25387
25388   jresult = (void *)result;
25389   return jresult;
25390 }
25391
25392
25393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyBuffer_SetData(void * jarg1, void * jarg2, unsigned long jarg3) {
25394   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25395   void *arg2 = (void *) 0 ;
25396   std::size_t arg3 ;
25397
25398   arg1 = (Dali::PropertyBuffer *)jarg1;
25399   arg2 = jarg2;
25400   arg3 = (std::size_t)jarg3;
25401   {
25402     try {
25403       (arg1)->SetData((void const *)arg2,arg3);
25404     } catch (std::out_of_range& e) {
25405       {
25406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25407       };
25408     } catch (std::exception& e) {
25409       {
25410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25411       };
25412     } catch (Dali::DaliException e) {
25413       {
25414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25415       };
25416     } catch (...) {
25417       {
25418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25419       };
25420     }
25421   }
25422
25423 }
25424
25425
25426 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyBuffer_GetSize(void * jarg1) {
25427   unsigned long jresult ;
25428   Dali::PropertyBuffer *arg1 = (Dali::PropertyBuffer *) 0 ;
25429   std::size_t result;
25430
25431   arg1 = (Dali::PropertyBuffer *)jarg1;
25432   {
25433     try {
25434       result = ((Dali::PropertyBuffer const *)arg1)->GetSize();
25435     } catch (std::out_of_range& e) {
25436       {
25437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25438       };
25439     } catch (std::exception& e) {
25440       {
25441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25442       };
25443     } catch (Dali::DaliException e) {
25444       {
25445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25446       };
25447     } catch (...) {
25448       {
25449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25450       };
25451     }
25452   }
25453
25454   jresult = (unsigned long)result;
25455   return jresult;
25456 }
25457
25458
25459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_New() {
25460   void * jresult ;
25461   Dali::Geometry result;
25462
25463   {
25464     try {
25465       result = Dali::Geometry::New();
25466     } catch (std::out_of_range& e) {
25467       {
25468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25469       };
25470     } catch (std::exception& e) {
25471       {
25472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25473       };
25474     } catch (Dali::DaliException e) {
25475       {
25476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25477       };
25478     } catch (...) {
25479       {
25480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25481       };
25482     }
25483   }
25484
25485   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25486   return jresult;
25487 }
25488
25489
25490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_0() {
25491   void * jresult ;
25492   Dali::Geometry *result = 0 ;
25493
25494   {
25495     try {
25496       result = (Dali::Geometry *)new Dali::Geometry();
25497     } catch (std::out_of_range& e) {
25498       {
25499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25500       };
25501     } catch (std::exception& e) {
25502       {
25503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25504       };
25505     } catch (Dali::DaliException e) {
25506       {
25507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25508       };
25509     } catch (...) {
25510       {
25511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25512       };
25513     }
25514   }
25515
25516   jresult = (void *)result;
25517   return jresult;
25518 }
25519
25520
25521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Geometry(void * jarg1) {
25522   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25523
25524   arg1 = (Dali::Geometry *)jarg1;
25525   {
25526     try {
25527       delete arg1;
25528     } catch (std::out_of_range& e) {
25529       {
25530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25531       };
25532     } catch (std::exception& e) {
25533       {
25534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25535       };
25536     } catch (Dali::DaliException e) {
25537       {
25538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25539       };
25540     } catch (...) {
25541       {
25542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25543       };
25544     }
25545   }
25546
25547 }
25548
25549
25550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Geometry__SWIG_1(void * jarg1) {
25551   void * jresult ;
25552   Dali::Geometry *arg1 = 0 ;
25553   Dali::Geometry *result = 0 ;
25554
25555   arg1 = (Dali::Geometry *)jarg1;
25556   if (!arg1) {
25557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25558     return 0;
25559   }
25560   {
25561     try {
25562       result = (Dali::Geometry *)new Dali::Geometry((Dali::Geometry const &)*arg1);
25563     } catch (std::out_of_range& e) {
25564       {
25565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25566       };
25567     } catch (std::exception& e) {
25568       {
25569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25570       };
25571     } catch (Dali::DaliException e) {
25572       {
25573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25574       };
25575     } catch (...) {
25576       {
25577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25578       };
25579     }
25580   }
25581
25582   jresult = (void *)result;
25583   return jresult;
25584 }
25585
25586
25587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_DownCast(void * jarg1) {
25588   void * jresult ;
25589   Dali::BaseHandle arg1 ;
25590   Dali::BaseHandle *argp1 ;
25591   Dali::Geometry result;
25592
25593   argp1 = (Dali::BaseHandle *)jarg1;
25594   if (!argp1) {
25595     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
25596     return 0;
25597   }
25598   arg1 = *argp1;
25599   {
25600     try {
25601       result = Dali::Geometry::DownCast(arg1);
25602     } catch (std::out_of_range& e) {
25603       {
25604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25605       };
25606     } catch (std::exception& e) {
25607       {
25608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25609       };
25610     } catch (Dali::DaliException e) {
25611       {
25612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25613       };
25614     } catch (...) {
25615       {
25616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25617       };
25618     }
25619   }
25620
25621   jresult = new Dali::Geometry((const Dali::Geometry &)result);
25622   return jresult;
25623 }
25624
25625
25626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Geometry_Assign(void * jarg1, void * jarg2) {
25627   void * jresult ;
25628   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25629   Dali::Geometry *arg2 = 0 ;
25630   Dali::Geometry *result = 0 ;
25631
25632   arg1 = (Dali::Geometry *)jarg1;
25633   arg2 = (Dali::Geometry *)jarg2;
25634   if (!arg2) {
25635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry const & type is null", 0);
25636     return 0;
25637   }
25638   {
25639     try {
25640       result = (Dali::Geometry *) &(arg1)->operator =((Dali::Geometry const &)*arg2);
25641     } catch (std::out_of_range& e) {
25642       {
25643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25644       };
25645     } catch (std::exception& e) {
25646       {
25647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25648       };
25649     } catch (Dali::DaliException e) {
25650       {
25651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25652       };
25653     } catch (...) {
25654       {
25655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25656       };
25657     }
25658   }
25659
25660   jresult = (void *)result;
25661   return jresult;
25662 }
25663
25664
25665 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_AddVertexBuffer(void * jarg1, void * jarg2) {
25666   unsigned long jresult ;
25667   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25668   Dali::PropertyBuffer *arg2 = 0 ;
25669   std::size_t result;
25670
25671   arg1 = (Dali::Geometry *)jarg1;
25672   arg2 = (Dali::PropertyBuffer *)jarg2;
25673   if (!arg2) {
25674     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyBuffer & type is null", 0);
25675     return 0;
25676   }
25677   {
25678     try {
25679       result = (arg1)->AddVertexBuffer(*arg2);
25680     } catch (std::out_of_range& e) {
25681       {
25682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25683       };
25684     } catch (std::exception& e) {
25685       {
25686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25687       };
25688     } catch (Dali::DaliException e) {
25689       {
25690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25691       };
25692     } catch (...) {
25693       {
25694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25695       };
25696     }
25697   }
25698
25699   jresult = (unsigned long)result;
25700   return jresult;
25701 }
25702
25703
25704 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Geometry_GetNumberOfVertexBuffers(void * jarg1) {
25705   unsigned long jresult ;
25706   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25707   std::size_t result;
25708
25709   arg1 = (Dali::Geometry *)jarg1;
25710   {
25711     try {
25712       result = ((Dali::Geometry const *)arg1)->GetNumberOfVertexBuffers();
25713     } catch (std::out_of_range& e) {
25714       {
25715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25716       };
25717     } catch (std::exception& e) {
25718       {
25719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25720       };
25721     } catch (Dali::DaliException e) {
25722       {
25723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25724       };
25725     } catch (...) {
25726       {
25727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25728       };
25729     }
25730   }
25731
25732   jresult = (unsigned long)result;
25733   return jresult;
25734 }
25735
25736
25737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_RemoveVertexBuffer(void * jarg1, unsigned long jarg2) {
25738   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25739   std::size_t arg2 ;
25740
25741   arg1 = (Dali::Geometry *)jarg1;
25742   arg2 = (std::size_t)jarg2;
25743   {
25744     try {
25745       (arg1)->RemoveVertexBuffer(arg2);
25746     } catch (std::out_of_range& e) {
25747       {
25748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25749       };
25750     } catch (std::exception& e) {
25751       {
25752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25753       };
25754     } catch (Dali::DaliException e) {
25755       {
25756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25757       };
25758     } catch (...) {
25759       {
25760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25761       };
25762     }
25763   }
25764
25765 }
25766
25767
25768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetIndexBuffer(void * jarg1, unsigned short* jarg2, unsigned long jarg3) {
25769   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25770   unsigned short *arg2 = (unsigned short *) 0 ;
25771   size_t arg3 ;
25772
25773   arg1 = (Dali::Geometry *)jarg1;
25774   arg2 = jarg2;
25775   arg3 = (size_t)jarg3;
25776   {
25777     try {
25778       (arg1)->SetIndexBuffer((unsigned short const *)arg2,arg3);
25779     } catch (std::out_of_range& e) {
25780       {
25781         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25782       };
25783     } catch (std::exception& e) {
25784       {
25785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25786       };
25787     } catch (Dali::DaliException e) {
25788       {
25789         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25790       };
25791     } catch (...) {
25792       {
25793         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25794       };
25795     }
25796   }
25797
25798
25799
25800 }
25801
25802
25803 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Geometry_SetType(void * jarg1, int jarg2) {
25804   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25805   Dali::Geometry::Type arg2 ;
25806
25807   arg1 = (Dali::Geometry *)jarg1;
25808   arg2 = (Dali::Geometry::Type)jarg2;
25809   {
25810     try {
25811       (arg1)->SetType(arg2);
25812     } catch (std::out_of_range& e) {
25813       {
25814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25815       };
25816     } catch (std::exception& e) {
25817       {
25818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25819       };
25820     } catch (Dali::DaliException e) {
25821       {
25822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25823       };
25824     } catch (...) {
25825       {
25826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25827       };
25828     }
25829   }
25830
25831 }
25832
25833
25834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Geometry_GetType(void * jarg1) {
25835   int jresult ;
25836   Dali::Geometry *arg1 = (Dali::Geometry *) 0 ;
25837   Dali::Geometry::Type result;
25838
25839   arg1 = (Dali::Geometry *)jarg1;
25840   {
25841     try {
25842       result = (Dali::Geometry::Type)((Dali::Geometry const *)arg1)->GetType();
25843     } catch (std::out_of_range& e) {
25844       {
25845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25846       };
25847     } catch (std::exception& e) {
25848       {
25849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25850       };
25851     } catch (Dali::DaliException e) {
25852       {
25853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25854       };
25855     } catch (...) {
25856       {
25857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25858       };
25859     }
25860   }
25861
25862   jresult = (int)result;
25863   return jresult;
25864 }
25865
25866
25867 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Hint() {
25868   void * jresult ;
25869   Dali::Shader::Hint *result = 0 ;
25870
25871   {
25872     try {
25873       result = (Dali::Shader::Hint *)new Dali::Shader::Hint();
25874     } catch (std::out_of_range& e) {
25875       {
25876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25877       };
25878     } catch (std::exception& e) {
25879       {
25880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25881       };
25882     } catch (Dali::DaliException e) {
25883       {
25884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25885       };
25886     } catch (...) {
25887       {
25888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25889       };
25890     }
25891   }
25892
25893   jresult = (void *)result;
25894   return jresult;
25895 }
25896
25897
25898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Hint(void * jarg1) {
25899   Dali::Shader::Hint *arg1 = (Dali::Shader::Hint *) 0 ;
25900
25901   arg1 = (Dali::Shader::Hint *)jarg1;
25902   {
25903     try {
25904       delete arg1;
25905     } catch (std::out_of_range& e) {
25906       {
25907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25908       };
25909     } catch (std::exception& e) {
25910       {
25911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25912       };
25913     } catch (Dali::DaliException e) {
25914       {
25915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25916       };
25917     } catch (...) {
25918       {
25919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25920       };
25921     }
25922   }
25923
25924 }
25925
25926
25927 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Shader_Property_PROGRAM_get() {
25928   int jresult ;
25929   int result;
25930
25931   result = (int)Dali::Shader::Property::PROGRAM;
25932   jresult = (int)result;
25933   return jresult;
25934 }
25935
25936
25937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader_Property() {
25938   void * jresult ;
25939   Dali::Shader::Property *result = 0 ;
25940
25941   {
25942     try {
25943       result = (Dali::Shader::Property *)new Dali::Shader::Property();
25944     } catch (std::out_of_range& e) {
25945       {
25946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
25947       };
25948     } catch (std::exception& e) {
25949       {
25950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
25951       };
25952     } catch (Dali::DaliException e) {
25953       {
25954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
25955       };
25956     } catch (...) {
25957       {
25958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
25959       };
25960     }
25961   }
25962
25963   jresult = (void *)result;
25964   return jresult;
25965 }
25966
25967
25968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader_Property(void * jarg1) {
25969   Dali::Shader::Property *arg1 = (Dali::Shader::Property *) 0 ;
25970
25971   arg1 = (Dali::Shader::Property *)jarg1;
25972   {
25973     try {
25974       delete arg1;
25975     } catch (std::out_of_range& e) {
25976       {
25977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
25978       };
25979     } catch (std::exception& e) {
25980       {
25981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
25982       };
25983     } catch (Dali::DaliException e) {
25984       {
25985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
25986       };
25987     } catch (...) {
25988       {
25989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
25990       };
25991     }
25992   }
25993
25994 }
25995
25996
25997 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_0(char * jarg1, char * jarg2, int jarg3) {
25998   void * jresult ;
25999   std::string *arg1 = 0 ;
26000   std::string *arg2 = 0 ;
26001   Dali::Shader::Hint::Value arg3 ;
26002   Dali::Shader result;
26003
26004   if (!jarg1) {
26005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26006     return 0;
26007   }
26008   std::string arg1_str(jarg1);
26009   arg1 = &arg1_str;
26010   if (!jarg2) {
26011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26012     return 0;
26013   }
26014   std::string arg2_str(jarg2);
26015   arg2 = &arg2_str;
26016   arg3 = (Dali::Shader::Hint::Value)jarg3;
26017   {
26018     try {
26019       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2,arg3);
26020     } catch (std::out_of_range& e) {
26021       {
26022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26023       };
26024     } catch (std::exception& e) {
26025       {
26026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26027       };
26028     } catch (Dali::DaliException e) {
26029       {
26030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26031       };
26032     } catch (...) {
26033       {
26034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26035       };
26036     }
26037   }
26038
26039   jresult = new Dali::Shader((const Dali::Shader &)result);
26040
26041   //argout typemap for const std::string&
26042
26043
26044   //argout typemap for const std::string&
26045
26046   return jresult;
26047 }
26048
26049
26050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_New__SWIG_1(char * jarg1, char * jarg2) {
26051   void * jresult ;
26052   std::string *arg1 = 0 ;
26053   std::string *arg2 = 0 ;
26054   Dali::Shader result;
26055
26056   if (!jarg1) {
26057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26058     return 0;
26059   }
26060   std::string arg1_str(jarg1);
26061   arg1 = &arg1_str;
26062   if (!jarg2) {
26063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
26064     return 0;
26065   }
26066   std::string arg2_str(jarg2);
26067   arg2 = &arg2_str;
26068   {
26069     try {
26070       result = Dali::Shader::New((std::string const &)*arg1,(std::string const &)*arg2);
26071     } catch (std::out_of_range& e) {
26072       {
26073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26074       };
26075     } catch (std::exception& e) {
26076       {
26077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26078       };
26079     } catch (Dali::DaliException e) {
26080       {
26081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26082       };
26083     } catch (...) {
26084       {
26085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26086       };
26087     }
26088   }
26089
26090   jresult = new Dali::Shader((const Dali::Shader &)result);
26091
26092   //argout typemap for const std::string&
26093
26094
26095   //argout typemap for const std::string&
26096
26097   return jresult;
26098 }
26099
26100
26101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_0() {
26102   void * jresult ;
26103   Dali::Shader *result = 0 ;
26104
26105   {
26106     try {
26107       result = (Dali::Shader *)new Dali::Shader();
26108     } catch (std::out_of_range& e) {
26109       {
26110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26111       };
26112     } catch (std::exception& e) {
26113       {
26114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26115       };
26116     } catch (Dali::DaliException e) {
26117       {
26118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26119       };
26120     } catch (...) {
26121       {
26122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26123       };
26124     }
26125   }
26126
26127   jresult = (void *)result;
26128   return jresult;
26129 }
26130
26131
26132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Shader(void * jarg1) {
26133   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26134
26135   arg1 = (Dali::Shader *)jarg1;
26136   {
26137     try {
26138       delete arg1;
26139     } catch (std::out_of_range& e) {
26140       {
26141         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26142       };
26143     } catch (std::exception& e) {
26144       {
26145         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26146       };
26147     } catch (Dali::DaliException e) {
26148       {
26149         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26150       };
26151     } catch (...) {
26152       {
26153         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26154       };
26155     }
26156   }
26157
26158 }
26159
26160
26161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Shader__SWIG_1(void * jarg1) {
26162   void * jresult ;
26163   Dali::Shader *arg1 = 0 ;
26164   Dali::Shader *result = 0 ;
26165
26166   arg1 = (Dali::Shader *)jarg1;
26167   if (!arg1) {
26168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26169     return 0;
26170   }
26171   {
26172     try {
26173       result = (Dali::Shader *)new Dali::Shader((Dali::Shader const &)*arg1);
26174     } catch (std::out_of_range& e) {
26175       {
26176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26177       };
26178     } catch (std::exception& e) {
26179       {
26180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26181       };
26182     } catch (Dali::DaliException e) {
26183       {
26184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26185       };
26186     } catch (...) {
26187       {
26188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26189       };
26190     }
26191   }
26192
26193   jresult = (void *)result;
26194   return jresult;
26195 }
26196
26197
26198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_DownCast(void * jarg1) {
26199   void * jresult ;
26200   Dali::BaseHandle arg1 ;
26201   Dali::BaseHandle *argp1 ;
26202   Dali::Shader result;
26203
26204   argp1 = (Dali::BaseHandle *)jarg1;
26205   if (!argp1) {
26206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26207     return 0;
26208   }
26209   arg1 = *argp1;
26210   {
26211     try {
26212       result = Dali::Shader::DownCast(arg1);
26213     } catch (std::out_of_range& e) {
26214       {
26215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26216       };
26217     } catch (std::exception& e) {
26218       {
26219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26220       };
26221     } catch (Dali::DaliException e) {
26222       {
26223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26224       };
26225     } catch (...) {
26226       {
26227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26228       };
26229     }
26230   }
26231
26232   jresult = new Dali::Shader((const Dali::Shader &)result);
26233   return jresult;
26234 }
26235
26236
26237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Shader_Assign(void * jarg1, void * jarg2) {
26238   void * jresult ;
26239   Dali::Shader *arg1 = (Dali::Shader *) 0 ;
26240   Dali::Shader *arg2 = 0 ;
26241   Dali::Shader *result = 0 ;
26242
26243   arg1 = (Dali::Shader *)jarg1;
26244   arg2 = (Dali::Shader *)jarg2;
26245   if (!arg2) {
26246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader const & type is null", 0);
26247     return 0;
26248   }
26249   {
26250     try {
26251       result = (Dali::Shader *) &(arg1)->operator =((Dali::Shader const &)*arg2);
26252     } catch (std::out_of_range& e) {
26253       {
26254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26255       };
26256     } catch (std::exception& e) {
26257       {
26258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26259       };
26260     } catch (Dali::DaliException e) {
26261       {
26262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26263       };
26264     } catch (...) {
26265       {
26266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26267       };
26268     }
26269   }
26270
26271   jresult = (void *)result;
26272   return jresult;
26273 }
26274
26275
26276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_EFFECT_get() {
26277   int jresult ;
26278   int result;
26279
26280   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND_EFFECT;
26281   jresult = (int)result;
26282   return jresult;
26283 }
26284
26285
26286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_BACKGROUND_get() {
26287   int jresult ;
26288   int result;
26289
26290   result = (int)Dali::Toolkit::DepthIndex::Ranges::BACKGROUND;
26291   jresult = (int)result;
26292   return jresult;
26293 }
26294
26295
26296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_CONTENT_get() {
26297   int jresult ;
26298   int result;
26299
26300   result = (int)Dali::Toolkit::DepthIndex::Ranges::CONTENT;
26301   jresult = (int)result;
26302   return jresult;
26303 }
26304
26305
26306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_DECORATION_get() {
26307   int jresult ;
26308   int result;
26309
26310   result = (int)Dali::Toolkit::DepthIndex::Ranges::DECORATION;
26311   jresult = (int)result;
26312   return jresult;
26313 }
26314
26315
26316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Range_FOREGROUND_EFFECT_get() {
26317   int jresult ;
26318   int result;
26319
26320   result = (int)Dali::Toolkit::DepthIndex::FOREGROUND_EFFECT;
26321   jresult = (int)result;
26322   return jresult;
26323 }
26324
26325
26326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_INDEX_get() {
26327   int jresult ;
26328   int result;
26329
26330   result = (int)Dali::Renderer::Property::DEPTH_INDEX;
26331   jresult = (int)result;
26332   return jresult;
26333 }
26334
26335
26336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_FACE_CULLING_MODE_get() {
26337   int jresult ;
26338   int result;
26339
26340   result = (int)Dali::Renderer::Property::FACE_CULLING_MODE;
26341   jresult = (int)result;
26342   return jresult;
26343 }
26344
26345
26346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_MODE_get() {
26347   int jresult ;
26348   int result;
26349
26350   result = (int)Dali::Renderer::Property::BLEND_MODE;
26351   jresult = (int)result;
26352   return jresult;
26353 }
26354
26355
26356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_RGB_get() {
26357   int jresult ;
26358   int result;
26359
26360   result = (int)Dali::Renderer::Property::BLEND_EQUATION_RGB;
26361   jresult = (int)result;
26362   return jresult;
26363 }
26364
26365
26366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_EQUATION_ALPHA_get() {
26367   int jresult ;
26368   int result;
26369
26370   result = (int)Dali::Renderer::Property::BLEND_EQUATION_ALPHA;
26371   jresult = (int)result;
26372   return jresult;
26373 }
26374
26375
26376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_RGB_get() {
26377   int jresult ;
26378   int result;
26379
26380   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_RGB;
26381   jresult = (int)result;
26382   return jresult;
26383 }
26384
26385
26386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_RGB_get() {
26387   int jresult ;
26388   int result;
26389
26390   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_RGB;
26391   jresult = (int)result;
26392   return jresult;
26393 }
26394
26395
26396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_SRC_ALPHA_get() {
26397   int jresult ;
26398   int result;
26399
26400   result = (int)Dali::Renderer::Property::BLEND_FACTOR_SRC_ALPHA;
26401   jresult = (int)result;
26402   return jresult;
26403 }
26404
26405
26406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_FACTOR_DEST_ALPHA_get() {
26407   int jresult ;
26408   int result;
26409
26410   result = (int)Dali::Renderer::Property::BLEND_FACTOR_DEST_ALPHA;
26411   jresult = (int)result;
26412   return jresult;
26413 }
26414
26415
26416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_COLOR_get() {
26417   int jresult ;
26418   int result;
26419
26420   result = (int)Dali::Renderer::Property::BLEND_COLOR;
26421   jresult = (int)result;
26422   return jresult;
26423 }
26424
26425
26426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_BLEND_PRE_MULTIPLIED_ALPHA_get() {
26427   int jresult ;
26428   int result;
26429
26430   result = (int)Dali::Renderer::Property::BLEND_PRE_MULTIPLIED_ALPHA;
26431   jresult = (int)result;
26432   return jresult;
26433 }
26434
26435
26436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_FIRST_get() {
26437   int jresult ;
26438   int result;
26439
26440   result = (int)Dali::Renderer::Property::INDEX_RANGE_FIRST;
26441   jresult = (int)result;
26442   return jresult;
26443 }
26444
26445
26446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_INDEX_RANGE_COUNT_get() {
26447   int jresult ;
26448   int result;
26449
26450   result = (int)Dali::Renderer::Property::INDEX_RANGE_COUNT;
26451   jresult = (int)result;
26452   return jresult;
26453 }
26454
26455
26456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_WRITE_MODE_get() {
26457   int jresult ;
26458   int result;
26459
26460   result = (int)Dali::Renderer::Property::DEPTH_WRITE_MODE;
26461   jresult = (int)result;
26462   return jresult;
26463 }
26464
26465
26466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_FUNCTION_get() {
26467   int jresult ;
26468   int result;
26469
26470   result = (int)Dali::Renderer::Property::DEPTH_FUNCTION;
26471   jresult = (int)result;
26472   return jresult;
26473 }
26474
26475
26476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_DEPTH_TEST_MODE_get() {
26477   int jresult ;
26478   int result;
26479
26480   result = (int)Dali::Renderer::Property::DEPTH_TEST_MODE;
26481   jresult = (int)result;
26482   return jresult;
26483 }
26484
26485
26486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_RENDER_MODE_get() {
26487   int jresult ;
26488   int result;
26489
26490   result = (int)Dali::Renderer::Property::RENDER_MODE;
26491   jresult = (int)result;
26492   return jresult;
26493 }
26494
26495
26496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_get() {
26497   int jresult ;
26498   int result;
26499
26500   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION;
26501   jresult = (int)result;
26502   return jresult;
26503 }
26504
26505
26506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_MASK_get() {
26507   int jresult ;
26508   int result;
26509
26510   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_MASK;
26511   jresult = (int)result;
26512   return jresult;
26513 }
26514
26515
26516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_FUNCTION_REFERENCE_get() {
26517   int jresult ;
26518   int result;
26519
26520   result = (int)Dali::Renderer::Property::STENCIL_FUNCTION_REFERENCE;
26521   jresult = (int)result;
26522   return jresult;
26523 }
26524
26525
26526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_MASK_get() {
26527   int jresult ;
26528   int result;
26529
26530   result = (int)Dali::Renderer::Property::STENCIL_MASK;
26531   jresult = (int)result;
26532   return jresult;
26533 }
26534
26535
26536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_FAIL_get() {
26537   int jresult ;
26538   int result;
26539
26540   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_FAIL;
26541   jresult = (int)result;
26542   return jresult;
26543 }
26544
26545
26546 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_FAIL_get() {
26547   int jresult ;
26548   int result;
26549
26550   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_FAIL;
26551   jresult = (int)result;
26552   return jresult;
26553 }
26554
26555
26556 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Renderer_Property_STENCIL_OPERATION_ON_Z_PASS_get() {
26557   int jresult ;
26558   int result;
26559
26560   result = (int)Dali::Renderer::Property::STENCIL_OPERATION_ON_Z_PASS;
26561   jresult = (int)result;
26562   return jresult;
26563 }
26564
26565
26566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer_Property() {
26567   void * jresult ;
26568   Dali::Renderer::Property *result = 0 ;
26569
26570   {
26571     try {
26572       result = (Dali::Renderer::Property *)new Dali::Renderer::Property();
26573     } catch (std::out_of_range& e) {
26574       {
26575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26576       };
26577     } catch (std::exception& e) {
26578       {
26579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26580       };
26581     } catch (Dali::DaliException e) {
26582       {
26583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26584       };
26585     } catch (...) {
26586       {
26587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26588       };
26589     }
26590   }
26591
26592   jresult = (void *)result;
26593   return jresult;
26594 }
26595
26596
26597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer_Property(void * jarg1) {
26598   Dali::Renderer::Property *arg1 = (Dali::Renderer::Property *) 0 ;
26599
26600   arg1 = (Dali::Renderer::Property *)jarg1;
26601   {
26602     try {
26603       delete arg1;
26604     } catch (std::out_of_range& e) {
26605       {
26606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26607       };
26608     } catch (std::exception& e) {
26609       {
26610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26611       };
26612     } catch (Dali::DaliException e) {
26613       {
26614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26615       };
26616     } catch (...) {
26617       {
26618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26619       };
26620     }
26621   }
26622
26623 }
26624
26625
26626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_New(void * jarg1, void * jarg2) {
26627   void * jresult ;
26628   Dali::Geometry *arg1 = 0 ;
26629   Dali::Shader *arg2 = 0 ;
26630   Dali::Renderer result;
26631
26632   arg1 = (Dali::Geometry *)jarg1;
26633   if (!arg1) {
26634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26635     return 0;
26636   }
26637   arg2 = (Dali::Shader *)jarg2;
26638   if (!arg2) {
26639     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
26640     return 0;
26641   }
26642   {
26643     try {
26644       result = Dali::Renderer::New(*arg1,*arg2);
26645     } catch (std::out_of_range& e) {
26646       {
26647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26648       };
26649     } catch (std::exception& e) {
26650       {
26651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26652       };
26653     } catch (Dali::DaliException e) {
26654       {
26655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26656       };
26657     } catch (...) {
26658       {
26659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26660       };
26661     }
26662   }
26663
26664   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26665   return jresult;
26666 }
26667
26668
26669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_0() {
26670   void * jresult ;
26671   Dali::Renderer *result = 0 ;
26672
26673   {
26674     try {
26675       result = (Dali::Renderer *)new Dali::Renderer();
26676     } catch (std::out_of_range& e) {
26677       {
26678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26679       };
26680     } catch (std::exception& e) {
26681       {
26682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26683       };
26684     } catch (Dali::DaliException e) {
26685       {
26686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26687       };
26688     } catch (...) {
26689       {
26690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26691       };
26692     }
26693   }
26694
26695   jresult = (void *)result;
26696   return jresult;
26697 }
26698
26699
26700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Renderer(void * jarg1) {
26701   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26702
26703   arg1 = (Dali::Renderer *)jarg1;
26704   {
26705     try {
26706       delete arg1;
26707     } catch (std::out_of_range& e) {
26708       {
26709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26710       };
26711     } catch (std::exception& e) {
26712       {
26713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26714       };
26715     } catch (Dali::DaliException e) {
26716       {
26717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26718       };
26719     } catch (...) {
26720       {
26721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26722       };
26723     }
26724   }
26725
26726 }
26727
26728
26729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Renderer__SWIG_1(void * jarg1) {
26730   void * jresult ;
26731   Dali::Renderer *arg1 = 0 ;
26732   Dali::Renderer *result = 0 ;
26733
26734   arg1 = (Dali::Renderer *)jarg1;
26735   if (!arg1) {
26736     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26737     return 0;
26738   }
26739   {
26740     try {
26741       result = (Dali::Renderer *)new Dali::Renderer((Dali::Renderer const &)*arg1);
26742     } catch (std::out_of_range& e) {
26743       {
26744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26745       };
26746     } catch (std::exception& e) {
26747       {
26748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26749       };
26750     } catch (Dali::DaliException e) {
26751       {
26752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26753       };
26754     } catch (...) {
26755       {
26756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26757       };
26758     }
26759   }
26760
26761   jresult = (void *)result;
26762   return jresult;
26763 }
26764
26765
26766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_DownCast(void * jarg1) {
26767   void * jresult ;
26768   Dali::BaseHandle arg1 ;
26769   Dali::BaseHandle *argp1 ;
26770   Dali::Renderer result;
26771
26772   argp1 = (Dali::BaseHandle *)jarg1;
26773   if (!argp1) {
26774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
26775     return 0;
26776   }
26777   arg1 = *argp1;
26778   {
26779     try {
26780       result = Dali::Renderer::DownCast(arg1);
26781     } catch (std::out_of_range& e) {
26782       {
26783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26784       };
26785     } catch (std::exception& e) {
26786       {
26787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26788       };
26789     } catch (Dali::DaliException e) {
26790       {
26791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26792       };
26793     } catch (...) {
26794       {
26795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26796       };
26797     }
26798   }
26799
26800   jresult = new Dali::Renderer((const Dali::Renderer &)result);
26801   return jresult;
26802 }
26803
26804
26805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_Assign(void * jarg1, void * jarg2) {
26806   void * jresult ;
26807   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26808   Dali::Renderer *arg2 = 0 ;
26809   Dali::Renderer *result = 0 ;
26810
26811   arg1 = (Dali::Renderer *)jarg1;
26812   arg2 = (Dali::Renderer *)jarg2;
26813   if (!arg2) {
26814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer const & type is null", 0);
26815     return 0;
26816   }
26817   {
26818     try {
26819       result = (Dali::Renderer *) &(arg1)->operator =((Dali::Renderer const &)*arg2);
26820     } catch (std::out_of_range& e) {
26821       {
26822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26823       };
26824     } catch (std::exception& e) {
26825       {
26826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26827       };
26828     } catch (Dali::DaliException e) {
26829       {
26830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26831       };
26832     } catch (...) {
26833       {
26834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26835       };
26836     }
26837   }
26838
26839   jresult = (void *)result;
26840   return jresult;
26841 }
26842
26843
26844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetGeometry(void * jarg1, void * jarg2) {
26845   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26846   Dali::Geometry *arg2 = 0 ;
26847
26848   arg1 = (Dali::Renderer *)jarg1;
26849   arg2 = (Dali::Geometry *)jarg2;
26850   if (!arg2) {
26851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Geometry & type is null", 0);
26852     return ;
26853   }
26854   {
26855     try {
26856       (arg1)->SetGeometry(*arg2);
26857     } catch (std::out_of_range& e) {
26858       {
26859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26860       };
26861     } catch (std::exception& e) {
26862       {
26863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26864       };
26865     } catch (Dali::DaliException e) {
26866       {
26867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26868       };
26869     } catch (...) {
26870       {
26871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26872       };
26873     }
26874   }
26875
26876 }
26877
26878
26879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetGeometry(void * jarg1) {
26880   void * jresult ;
26881   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26882   Dali::Geometry result;
26883
26884   arg1 = (Dali::Renderer *)jarg1;
26885   {
26886     try {
26887       result = ((Dali::Renderer const *)arg1)->GetGeometry();
26888     } catch (std::out_of_range& e) {
26889       {
26890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26891       };
26892     } catch (std::exception& e) {
26893       {
26894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26895       };
26896     } catch (Dali::DaliException e) {
26897       {
26898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
26899       };
26900     } catch (...) {
26901       {
26902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
26903       };
26904     }
26905   }
26906
26907   jresult = new Dali::Geometry((const Dali::Geometry &)result);
26908   return jresult;
26909 }
26910
26911
26912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetIndexRange(void * jarg1, int jarg2, int jarg3) {
26913   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26914   int arg2 ;
26915   int arg3 ;
26916
26917   arg1 = (Dali::Renderer *)jarg1;
26918   arg2 = (int)jarg2;
26919   arg3 = (int)jarg3;
26920   {
26921     try {
26922       (arg1)->SetIndexRange(arg2,arg3);
26923     } catch (std::out_of_range& e) {
26924       {
26925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26926       };
26927     } catch (std::exception& e) {
26928       {
26929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26930       };
26931     } catch (Dali::DaliException e) {
26932       {
26933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26934       };
26935     } catch (...) {
26936       {
26937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26938       };
26939     }
26940   }
26941
26942 }
26943
26944
26945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetTextures(void * jarg1, void * jarg2) {
26946   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26947   Dali::TextureSet *arg2 = 0 ;
26948
26949   arg1 = (Dali::Renderer *)jarg1;
26950   arg2 = (Dali::TextureSet *)jarg2;
26951   if (!arg2) {
26952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TextureSet & type is null", 0);
26953     return ;
26954   }
26955   {
26956     try {
26957       (arg1)->SetTextures(*arg2);
26958     } catch (std::out_of_range& e) {
26959       {
26960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
26961       };
26962     } catch (std::exception& e) {
26963       {
26964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
26965       };
26966     } catch (Dali::DaliException e) {
26967       {
26968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
26969       };
26970     } catch (...) {
26971       {
26972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
26973       };
26974     }
26975   }
26976
26977 }
26978
26979
26980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetTextures(void * jarg1) {
26981   void * jresult ;
26982   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
26983   Dali::TextureSet result;
26984
26985   arg1 = (Dali::Renderer *)jarg1;
26986   {
26987     try {
26988       result = ((Dali::Renderer const *)arg1)->GetTextures();
26989     } catch (std::out_of_range& e) {
26990       {
26991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
26992       };
26993     } catch (std::exception& e) {
26994       {
26995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
26996       };
26997     } catch (Dali::DaliException e) {
26998       {
26999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27000       };
27001     } catch (...) {
27002       {
27003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27004       };
27005     }
27006   }
27007
27008   jresult = new Dali::TextureSet((const Dali::TextureSet &)result);
27009   return jresult;
27010 }
27011
27012
27013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Renderer_SetShader(void * jarg1, void * jarg2) {
27014   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27015   Dali::Shader *arg2 = 0 ;
27016
27017   arg1 = (Dali::Renderer *)jarg1;
27018   arg2 = (Dali::Shader *)jarg2;
27019   if (!arg2) {
27020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Shader & type is null", 0);
27021     return ;
27022   }
27023   {
27024     try {
27025       (arg1)->SetShader(*arg2);
27026     } catch (std::out_of_range& e) {
27027       {
27028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27029       };
27030     } catch (std::exception& e) {
27031       {
27032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27033       };
27034     } catch (Dali::DaliException e) {
27035       {
27036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27037       };
27038     } catch (...) {
27039       {
27040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27041       };
27042     }
27043   }
27044
27045 }
27046
27047
27048 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Renderer_GetShader(void * jarg1) {
27049   void * jresult ;
27050   Dali::Renderer *arg1 = (Dali::Renderer *) 0 ;
27051   Dali::Shader result;
27052
27053   arg1 = (Dali::Renderer *)jarg1;
27054   {
27055     try {
27056       result = ((Dali::Renderer const *)arg1)->GetShader();
27057     } catch (std::out_of_range& e) {
27058       {
27059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27060       };
27061     } catch (std::exception& e) {
27062       {
27063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27064       };
27065     } catch (Dali::DaliException e) {
27066       {
27067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27068       };
27069     } catch (...) {
27070       {
27071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27072       };
27073     }
27074   }
27075
27076   jresult = new Dali::Shader((const Dali::Shader &)result);
27077   return jresult;
27078 }
27079
27080
27081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer_Attachment() {
27082   void * jresult ;
27083   Dali::FrameBuffer::Attachment *result = 0 ;
27084
27085   {
27086     try {
27087       result = (Dali::FrameBuffer::Attachment *)new Dali::FrameBuffer::Attachment();
27088     } catch (std::out_of_range& e) {
27089       {
27090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27091       };
27092     } catch (std::exception& e) {
27093       {
27094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27095       };
27096     } catch (Dali::DaliException e) {
27097       {
27098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27099       };
27100     } catch (...) {
27101       {
27102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27103       };
27104     }
27105   }
27106
27107   jresult = (void *)result;
27108   return jresult;
27109 }
27110
27111
27112 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer_Attachment(void * jarg1) {
27113   Dali::FrameBuffer::Attachment *arg1 = (Dali::FrameBuffer::Attachment *) 0 ;
27114
27115   arg1 = (Dali::FrameBuffer::Attachment *)jarg1;
27116   {
27117     try {
27118       delete arg1;
27119     } catch (std::out_of_range& e) {
27120       {
27121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27122       };
27123     } catch (std::exception& e) {
27124       {
27125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27126       };
27127     } catch (Dali::DaliException e) {
27128       {
27129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27130       };
27131     } catch (...) {
27132       {
27133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27134       };
27135     }
27136   }
27137
27138 }
27139
27140
27141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_New(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
27142   void * jresult ;
27143   unsigned int arg1 ;
27144   unsigned int arg2 ;
27145   unsigned int arg3 ;
27146   Dali::FrameBuffer result;
27147
27148   arg1 = (unsigned int)jarg1;
27149   arg2 = (unsigned int)jarg2;
27150   arg3 = (unsigned int)jarg3;
27151   {
27152     try {
27153       result = Dali::FrameBuffer::New(arg1,arg2,static_cast<Dali::FrameBuffer::Attachment::Mask>(arg3));
27154     } catch (std::out_of_range& e) {
27155       {
27156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27157       };
27158     } catch (std::exception& e) {
27159       {
27160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27161       };
27162     } catch (Dali::DaliException e) {
27163       {
27164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27165       };
27166     } catch (...) {
27167       {
27168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27169       };
27170     }
27171   }
27172
27173   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27174   return jresult;
27175 }
27176
27177
27178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_0() {
27179   void * jresult ;
27180   Dali::FrameBuffer *result = 0 ;
27181
27182   {
27183     try {
27184       result = (Dali::FrameBuffer *)new Dali::FrameBuffer();
27185     } catch (std::out_of_range& e) {
27186       {
27187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27188       };
27189     } catch (std::exception& e) {
27190       {
27191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27192       };
27193     } catch (Dali::DaliException e) {
27194       {
27195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27196       };
27197     } catch (...) {
27198       {
27199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27200       };
27201     }
27202   }
27203
27204   jresult = (void *)result;
27205   return jresult;
27206 }
27207
27208
27209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FrameBuffer(void * jarg1) {
27210   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27211
27212   arg1 = (Dali::FrameBuffer *)jarg1;
27213   {
27214     try {
27215       delete arg1;
27216     } catch (std::out_of_range& e) {
27217       {
27218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27219       };
27220     } catch (std::exception& e) {
27221       {
27222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27223       };
27224     } catch (Dali::DaliException e) {
27225       {
27226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27227       };
27228     } catch (...) {
27229       {
27230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27231       };
27232     }
27233   }
27234
27235 }
27236
27237
27238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FrameBuffer__SWIG_1(void * jarg1) {
27239   void * jresult ;
27240   Dali::FrameBuffer *arg1 = 0 ;
27241   Dali::FrameBuffer *result = 0 ;
27242
27243   arg1 = (Dali::FrameBuffer *)jarg1;
27244   if (!arg1) {
27245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27246     return 0;
27247   }
27248   {
27249     try {
27250       result = (Dali::FrameBuffer *)new Dali::FrameBuffer((Dali::FrameBuffer const &)*arg1);
27251     } catch (std::out_of_range& e) {
27252       {
27253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27254       };
27255     } catch (std::exception& e) {
27256       {
27257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27258       };
27259     } catch (Dali::DaliException e) {
27260       {
27261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27262       };
27263     } catch (...) {
27264       {
27265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27266       };
27267     }
27268   }
27269
27270   jresult = (void *)result;
27271   return jresult;
27272 }
27273
27274
27275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_DownCast(void * jarg1) {
27276   void * jresult ;
27277   Dali::BaseHandle arg1 ;
27278   Dali::BaseHandle *argp1 ;
27279   Dali::FrameBuffer result;
27280
27281   argp1 = (Dali::BaseHandle *)jarg1;
27282   if (!argp1) {
27283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27284     return 0;
27285   }
27286   arg1 = *argp1;
27287   {
27288     try {
27289       result = Dali::FrameBuffer::DownCast(arg1);
27290     } catch (std::out_of_range& e) {
27291       {
27292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27293       };
27294     } catch (std::exception& e) {
27295       {
27296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27297       };
27298     } catch (Dali::DaliException e) {
27299       {
27300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27301       };
27302     } catch (...) {
27303       {
27304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27305       };
27306     }
27307   }
27308
27309   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
27310   return jresult;
27311 }
27312
27313
27314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_Assign(void * jarg1, void * jarg2) {
27315   void * jresult ;
27316   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27317   Dali::FrameBuffer *arg2 = 0 ;
27318   Dali::FrameBuffer *result = 0 ;
27319
27320   arg1 = (Dali::FrameBuffer *)jarg1;
27321   arg2 = (Dali::FrameBuffer *)jarg2;
27322   if (!arg2) {
27323     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::FrameBuffer const & type is null", 0);
27324     return 0;
27325   }
27326   {
27327     try {
27328       result = (Dali::FrameBuffer *) &(arg1)->operator =((Dali::FrameBuffer const &)*arg2);
27329     } catch (std::out_of_range& e) {
27330       {
27331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27332       };
27333     } catch (std::exception& e) {
27334       {
27335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27336       };
27337     } catch (Dali::DaliException e) {
27338       {
27339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27340       };
27341     } catch (...) {
27342       {
27343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27344       };
27345     }
27346   }
27347
27348   jresult = (void *)result;
27349   return jresult;
27350 }
27351
27352
27353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_0(void * jarg1, void * jarg2) {
27354   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27355   Dali::Texture *arg2 = 0 ;
27356
27357   arg1 = (Dali::FrameBuffer *)jarg1;
27358   arg2 = (Dali::Texture *)jarg2;
27359   if (!arg2) {
27360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27361     return ;
27362   }
27363   {
27364     try {
27365       (arg1)->AttachColorTexture(*arg2);
27366     } catch (std::out_of_range& e) {
27367       {
27368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27369       };
27370     } catch (std::exception& e) {
27371       {
27372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27373       };
27374     } catch (Dali::DaliException e) {
27375       {
27376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27377       };
27378     } catch (...) {
27379       {
27380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27381       };
27382     }
27383   }
27384
27385 }
27386
27387
27388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FrameBuffer_AttachColorTexture__SWIG_1(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
27389   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27390   Dali::Texture *arg2 = 0 ;
27391   unsigned int arg3 ;
27392   unsigned int arg4 ;
27393
27394   arg1 = (Dali::FrameBuffer *)jarg1;
27395   arg2 = (Dali::Texture *)jarg2;
27396   if (!arg2) {
27397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Texture & type is null", 0);
27398     return ;
27399   }
27400   arg3 = (unsigned int)jarg3;
27401   arg4 = (unsigned int)jarg4;
27402   {
27403     try {
27404       (arg1)->AttachColorTexture(*arg2,arg3,arg4);
27405     } catch (std::out_of_range& e) {
27406       {
27407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27408       };
27409     } catch (std::exception& e) {
27410       {
27411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27412       };
27413     } catch (Dali::DaliException e) {
27414       {
27415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27416       };
27417     } catch (...) {
27418       {
27419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27420       };
27421     }
27422   }
27423
27424 }
27425
27426
27427 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FrameBuffer_GetColorTexture(void * jarg1) {
27428   void * jresult ;
27429   Dali::FrameBuffer *arg1 = (Dali::FrameBuffer *) 0 ;
27430   Dali::Texture result;
27431
27432   arg1 = (Dali::FrameBuffer *)jarg1;
27433   {
27434     try {
27435       result = (arg1)->GetColorTexture();
27436     } catch (std::out_of_range& e) {
27437       {
27438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27439       };
27440     } catch (std::exception& e) {
27441       {
27442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27443       };
27444     } catch (Dali::DaliException e) {
27445       {
27446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27447       };
27448     } catch (...) {
27449       {
27450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27451       };
27452     }
27453   }
27454
27455   jresult = new Dali::Texture((const Dali::Texture &)result);
27456   return jresult;
27457 }
27458
27459
27460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_0() {
27461   void * jresult ;
27462   Dali::RenderTaskList *result = 0 ;
27463
27464   {
27465     try {
27466       result = (Dali::RenderTaskList *)new Dali::RenderTaskList();
27467     } catch (std::out_of_range& e) {
27468       {
27469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27470       };
27471     } catch (std::exception& e) {
27472       {
27473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27474       };
27475     } catch (Dali::DaliException e) {
27476       {
27477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27478       };
27479     } catch (...) {
27480       {
27481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27482       };
27483     }
27484   }
27485
27486   jresult = (void *)result;
27487   return jresult;
27488 }
27489
27490
27491 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_DownCast(void * jarg1) {
27492   void * jresult ;
27493   Dali::BaseHandle arg1 ;
27494   Dali::BaseHandle *argp1 ;
27495   Dali::RenderTaskList result;
27496
27497   argp1 = (Dali::BaseHandle *)jarg1;
27498   if (!argp1) {
27499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27500     return 0;
27501   }
27502   arg1 = *argp1;
27503   {
27504     try {
27505       result = Dali::RenderTaskList::DownCast(arg1);
27506     } catch (std::out_of_range& e) {
27507       {
27508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27509       };
27510     } catch (std::exception& e) {
27511       {
27512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27513       };
27514     } catch (Dali::DaliException e) {
27515       {
27516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27517       };
27518     } catch (...) {
27519       {
27520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27521       };
27522     }
27523   }
27524
27525   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
27526   return jresult;
27527 }
27528
27529
27530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskList(void * jarg1) {
27531   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27532
27533   arg1 = (Dali::RenderTaskList *)jarg1;
27534   {
27535     try {
27536       delete arg1;
27537     } catch (std::out_of_range& e) {
27538       {
27539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27540       };
27541     } catch (std::exception& e) {
27542       {
27543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27544       };
27545     } catch (Dali::DaliException e) {
27546       {
27547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27548       };
27549     } catch (...) {
27550       {
27551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27552       };
27553     }
27554   }
27555
27556 }
27557
27558
27559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskList__SWIG_1(void * jarg1) {
27560   void * jresult ;
27561   Dali::RenderTaskList *arg1 = 0 ;
27562   Dali::RenderTaskList *result = 0 ;
27563
27564   arg1 = (Dali::RenderTaskList *)jarg1;
27565   if (!arg1) {
27566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27567     return 0;
27568   }
27569   {
27570     try {
27571       result = (Dali::RenderTaskList *)new Dali::RenderTaskList((Dali::RenderTaskList const &)*arg1);
27572     } catch (std::out_of_range& e) {
27573       {
27574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27575       };
27576     } catch (std::exception& e) {
27577       {
27578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27579       };
27580     } catch (Dali::DaliException e) {
27581       {
27582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27583       };
27584     } catch (...) {
27585       {
27586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27587       };
27588     }
27589   }
27590
27591   jresult = (void *)result;
27592   return jresult;
27593 }
27594
27595
27596 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_Assign(void * jarg1, void * jarg2) {
27597   void * jresult ;
27598   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27599   Dali::RenderTaskList *arg2 = 0 ;
27600   Dali::RenderTaskList *result = 0 ;
27601
27602   arg1 = (Dali::RenderTaskList *)jarg1;
27603   arg2 = (Dali::RenderTaskList *)jarg2;
27604   if (!arg2) {
27605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTaskList const & type is null", 0);
27606     return 0;
27607   }
27608   {
27609     try {
27610       result = (Dali::RenderTaskList *) &(arg1)->operator =((Dali::RenderTaskList const &)*arg2);
27611     } catch (std::out_of_range& e) {
27612       {
27613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27614       };
27615     } catch (std::exception& e) {
27616       {
27617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27618       };
27619     } catch (Dali::DaliException e) {
27620       {
27621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27622       };
27623     } catch (...) {
27624       {
27625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27626       };
27627     }
27628   }
27629
27630   jresult = (void *)result;
27631   return jresult;
27632 }
27633
27634
27635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_CreateTask(void * jarg1) {
27636   void * jresult ;
27637   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27638   Dali::RenderTask result;
27639
27640   arg1 = (Dali::RenderTaskList *)jarg1;
27641   {
27642     try {
27643       result = (arg1)->CreateTask();
27644     } catch (std::out_of_range& e) {
27645       {
27646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27647       };
27648     } catch (std::exception& e) {
27649       {
27650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27651       };
27652     } catch (Dali::DaliException e) {
27653       {
27654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27655       };
27656     } catch (...) {
27657       {
27658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27659       };
27660     }
27661   }
27662
27663   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27664   return jresult;
27665 }
27666
27667
27668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTaskList_RemoveTask(void * jarg1, void * jarg2) {
27669   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27670   Dali::RenderTask arg2 ;
27671   Dali::RenderTask *argp2 ;
27672
27673   arg1 = (Dali::RenderTaskList *)jarg1;
27674   argp2 = (Dali::RenderTask *)jarg2;
27675   if (!argp2) {
27676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::RenderTask", 0);
27677     return ;
27678   }
27679   arg2 = *argp2;
27680   {
27681     try {
27682       (arg1)->RemoveTask(arg2);
27683     } catch (std::out_of_range& e) {
27684       {
27685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27686       };
27687     } catch (std::exception& e) {
27688       {
27689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27690       };
27691     } catch (Dali::DaliException e) {
27692       {
27693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27694       };
27695     } catch (...) {
27696       {
27697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27698       };
27699     }
27700   }
27701
27702 }
27703
27704
27705 //// ===============================================end part 1 =================
27706
27707 //// ========================= part 2 ===============================
27708
27709 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTaskCount(void * jarg1) {
27710   unsigned int jresult ;
27711   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27712   unsigned int result;
27713
27714   arg1 = (Dali::RenderTaskList *)jarg1;
27715   {
27716     try {
27717       result = (unsigned int)((Dali::RenderTaskList const *)arg1)->GetTaskCount();
27718     } catch (std::out_of_range& e) {
27719       {
27720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27721       };
27722     } catch (std::exception& e) {
27723       {
27724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27725       };
27726     } catch (Dali::DaliException e) {
27727       {
27728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27729       };
27730     } catch (...) {
27731       {
27732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27733       };
27734     }
27735   }
27736
27737   jresult = result;
27738   return jresult;
27739 }
27740
27741
27742 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTaskList_GetTask(void * jarg1, unsigned int jarg2) {
27743   void * jresult ;
27744   Dali::RenderTaskList *arg1 = (Dali::RenderTaskList *) 0 ;
27745   unsigned int arg2 ;
27746   Dali::RenderTask result;
27747
27748   arg1 = (Dali::RenderTaskList *)jarg1;
27749   arg2 = (unsigned int)jarg2;
27750   {
27751     try {
27752       result = ((Dali::RenderTaskList const *)arg1)->GetTask(arg2);
27753     } catch (std::out_of_range& e) {
27754       {
27755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27756       };
27757     } catch (std::exception& e) {
27758       {
27759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27760       };
27761     } catch (Dali::DaliException e) {
27762       {
27763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27764       };
27765     } catch (...) {
27766       {
27767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27768       };
27769     }
27770   }
27771
27772   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
27773   return jresult;
27774 }
27775
27776
27777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_POSITION_get() {
27778   int jresult ;
27779   int result;
27780
27781   result = (int)Dali::RenderTask::Property::VIEWPORT_POSITION;
27782   jresult = (int)result;
27783   return jresult;
27784 }
27785
27786
27787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_VIEWPORT_SIZE_get() {
27788   int jresult ;
27789   int result;
27790
27791   result = (int)Dali::RenderTask::Property::VIEWPORT_SIZE;
27792   jresult = (int)result;
27793   return jresult;
27794 }
27795
27796
27797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_CLEAR_COLOR_get() {
27798   int jresult ;
27799   int result;
27800
27801   result = (int)Dali::RenderTask::Property::CLEAR_COLOR;
27802   jresult = (int)result;
27803   return jresult;
27804 }
27805
27806
27807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RenderTask_Property_REQUIRES_SYNC_get() {
27808   int jresult ;
27809   int result;
27810
27811   result = (int)Dali::RenderTask::Property::REQUIRES_SYNC;
27812   jresult = (int)result;
27813   return jresult;
27814 }
27815
27816
27817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask_Property() {
27818   void * jresult ;
27819   Dali::RenderTask::Property *result = 0 ;
27820
27821   {
27822     try {
27823       result = (Dali::RenderTask::Property *)new Dali::RenderTask::Property();
27824     } catch (std::out_of_range& e) {
27825       {
27826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27827       };
27828     } catch (std::exception& e) {
27829       {
27830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27831       };
27832     } catch (Dali::DaliException e) {
27833       {
27834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27835       };
27836     } catch (...) {
27837       {
27838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27839       };
27840     }
27841   }
27842
27843   jresult = (void *)result;
27844   return jresult;
27845 }
27846
27847
27848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask_Property(void * jarg1) {
27849   Dali::RenderTask::Property *arg1 = (Dali::RenderTask::Property *) 0 ;
27850
27851   arg1 = (Dali::RenderTask::Property *)jarg1;
27852   {
27853     try {
27854       delete arg1;
27855     } catch (std::out_of_range& e) {
27856       {
27857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
27858       };
27859     } catch (std::exception& e) {
27860       {
27861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
27862       };
27863     } catch (Dali::DaliException e) {
27864       {
27865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
27866       };
27867     } catch (...) {
27868       {
27869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
27870       };
27871     }
27872   }
27873
27874 }
27875
27876
27877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION_get() {
27878   void * jresult ;
27879   bool (*result)(Dali::Vector2 &) = 0 ;
27880
27881   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::DEFAULT_SCREEN_TO_FRAMEBUFFER_FUNCTION;
27882   jresult = (void *)result;
27883   return jresult;
27884 }
27885
27886
27887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FULLSCREEN_FRAMEBUFFER_FUNCTION_get() {
27888   void * jresult ;
27889   bool (*result)(Dali::Vector2 &) = 0 ;
27890
27891   result = (bool (*)(Dali::Vector2 &))Dali::RenderTask::FULLSCREEN_FRAMEBUFFER_FUNCTION;
27892   jresult = (void *)result;
27893   return jresult;
27894 }
27895
27896
27897 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_EXCLUSIVE_get() {
27898   unsigned int jresult ;
27899   bool result;
27900
27901   result = (bool)(bool)Dali::RenderTask::DEFAULT_EXCLUSIVE;
27902   jresult = result;
27903   return jresult;
27904 }
27905
27906
27907 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_INPUT_ENABLED_get() {
27908   unsigned int jresult ;
27909   bool result;
27910
27911   result = (bool)(bool)Dali::RenderTask::DEFAULT_INPUT_ENABLED;
27912   jresult = result;
27913   return jresult;
27914 }
27915
27916
27917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_COLOR_get() {
27918   void * jresult ;
27919   Dali::Vector4 *result = 0 ;
27920
27921   result = (Dali::Vector4 *)&Dali::RenderTask::DEFAULT_CLEAR_COLOR;
27922   jresult = (void *)result;
27923   return jresult;
27924 }
27925
27926
27927 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CLEAR_ENABLED_get() {
27928   unsigned int jresult ;
27929   bool result;
27930
27931   result = (bool)(bool)Dali::RenderTask::DEFAULT_CLEAR_ENABLED;
27932   jresult = result;
27933   return jresult;
27934 }
27935
27936
27937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_CULL_MODE_get() {
27938   unsigned int jresult ;
27939   bool result;
27940
27941   result = (bool)(bool)Dali::RenderTask::DEFAULT_CULL_MODE;
27942   jresult = result;
27943   return jresult;
27944 }
27945
27946
27947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_DEFAULT_REFRESH_RATE_get() {
27948   unsigned int jresult ;
27949   unsigned int result;
27950
27951   result = (unsigned int)(unsigned int)Dali::RenderTask::DEFAULT_REFRESH_RATE;
27952   jresult = result;
27953   return jresult;
27954 }
27955
27956
27957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_0() {
27958   void * jresult ;
27959   Dali::RenderTask *result = 0 ;
27960
27961   {
27962     try {
27963       result = (Dali::RenderTask *)new Dali::RenderTask();
27964     } catch (std::out_of_range& e) {
27965       {
27966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
27967       };
27968     } catch (std::exception& e) {
27969       {
27970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
27971       };
27972     } catch (Dali::DaliException e) {
27973       {
27974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
27975       };
27976     } catch (...) {
27977       {
27978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
27979       };
27980     }
27981   }
27982
27983   jresult = (void *)result;
27984   return jresult;
27985 }
27986
27987
27988 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_DownCast(void * jarg1) {
27989   void * jresult ;
27990   Dali::BaseHandle arg1 ;
27991   Dali::BaseHandle *argp1 ;
27992   Dali::RenderTask result;
27993
27994   argp1 = (Dali::BaseHandle *)jarg1;
27995   if (!argp1) {
27996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
27997     return 0;
27998   }
27999   arg1 = *argp1;
28000   {
28001     try {
28002       result = Dali::RenderTask::DownCast(arg1);
28003     } catch (std::out_of_range& e) {
28004       {
28005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28006       };
28007     } catch (std::exception& e) {
28008       {
28009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28010       };
28011     } catch (Dali::DaliException e) {
28012       {
28013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28014       };
28015     } catch (...) {
28016       {
28017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28018       };
28019     }
28020   }
28021
28022   jresult = new Dali::RenderTask((const Dali::RenderTask &)result);
28023   return jresult;
28024 }
28025
28026
28027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTask(void * jarg1) {
28028   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28029
28030   arg1 = (Dali::RenderTask *)jarg1;
28031   {
28032     try {
28033       delete arg1;
28034     } catch (std::out_of_range& e) {
28035       {
28036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28037       };
28038     } catch (std::exception& e) {
28039       {
28040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28041       };
28042     } catch (Dali::DaliException e) {
28043       {
28044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28045       };
28046     } catch (...) {
28047       {
28048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28049       };
28050     }
28051   }
28052
28053 }
28054
28055
28056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTask__SWIG_1(void * jarg1) {
28057   void * jresult ;
28058   Dali::RenderTask *arg1 = 0 ;
28059   Dali::RenderTask *result = 0 ;
28060
28061   arg1 = (Dali::RenderTask *)jarg1;
28062   if (!arg1) {
28063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28064     return 0;
28065   }
28066   {
28067     try {
28068       result = (Dali::RenderTask *)new Dali::RenderTask((Dali::RenderTask const &)*arg1);
28069     } catch (std::out_of_range& e) {
28070       {
28071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28072       };
28073     } catch (std::exception& e) {
28074       {
28075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28076       };
28077     } catch (Dali::DaliException e) {
28078       {
28079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28080       };
28081     } catch (...) {
28082       {
28083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28084       };
28085     }
28086   }
28087
28088   jresult = (void *)result;
28089   return jresult;
28090 }
28091
28092
28093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_Assign(void * jarg1, void * jarg2) {
28094   void * jresult ;
28095   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28096   Dali::RenderTask *arg2 = 0 ;
28097   Dali::RenderTask *result = 0 ;
28098
28099   arg1 = (Dali::RenderTask *)jarg1;
28100   arg2 = (Dali::RenderTask *)jarg2;
28101   if (!arg2) {
28102     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RenderTask const & type is null", 0);
28103     return 0;
28104   }
28105   {
28106     try {
28107       result = (Dali::RenderTask *) &(arg1)->operator =((Dali::RenderTask const &)*arg2);
28108     } catch (std::out_of_range& e) {
28109       {
28110         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28111       };
28112     } catch (std::exception& e) {
28113       {
28114         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28115       };
28116     } catch (Dali::DaliException e) {
28117       {
28118         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28119       };
28120     } catch (...) {
28121       {
28122         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28123       };
28124     }
28125   }
28126
28127   jresult = (void *)result;
28128   return jresult;
28129 }
28130
28131
28132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetSourceActor(void * jarg1, void * jarg2) {
28133   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28134   Dali::Actor arg2 ;
28135   Dali::Actor *argp2 ;
28136
28137   arg1 = (Dali::RenderTask *)jarg1;
28138   argp2 = (Dali::Actor *)jarg2;
28139   if (!argp2) {
28140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28141     return ;
28142   }
28143   arg2 = *argp2;
28144   {
28145     try {
28146       (arg1)->SetSourceActor(arg2);
28147     } catch (std::out_of_range& e) {
28148       {
28149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28150       };
28151     } catch (std::exception& e) {
28152       {
28153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28154       };
28155     } catch (Dali::DaliException e) {
28156       {
28157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28158       };
28159     } catch (...) {
28160       {
28161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28162       };
28163     }
28164   }
28165
28166 }
28167
28168
28169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetSourceActor(void * jarg1) {
28170   void * jresult ;
28171   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28172   Dali::Actor result;
28173
28174   arg1 = (Dali::RenderTask *)jarg1;
28175   {
28176     try {
28177       result = ((Dali::RenderTask const *)arg1)->GetSourceActor();
28178     } catch (std::out_of_range& e) {
28179       {
28180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28181       };
28182     } catch (std::exception& e) {
28183       {
28184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28185       };
28186     } catch (Dali::DaliException e) {
28187       {
28188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28189       };
28190     } catch (...) {
28191       {
28192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28193       };
28194     }
28195   }
28196
28197   jresult = new Dali::Actor((const Dali::Actor &)result);
28198   return jresult;
28199 }
28200
28201
28202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetExclusive(void * jarg1, unsigned int jarg2) {
28203   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28204   bool arg2 ;
28205
28206   arg1 = (Dali::RenderTask *)jarg1;
28207   arg2 = jarg2 ? true : false;
28208   {
28209     try {
28210       (arg1)->SetExclusive(arg2);
28211     } catch (std::out_of_range& e) {
28212       {
28213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28214       };
28215     } catch (std::exception& e) {
28216       {
28217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28218       };
28219     } catch (Dali::DaliException e) {
28220       {
28221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28222       };
28223     } catch (...) {
28224       {
28225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28226       };
28227     }
28228   }
28229
28230 }
28231
28232
28233 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_IsExclusive(void * jarg1) {
28234   unsigned int jresult ;
28235   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28236   bool result;
28237
28238   arg1 = (Dali::RenderTask *)jarg1;
28239   {
28240     try {
28241       result = (bool)((Dali::RenderTask const *)arg1)->IsExclusive();
28242     } catch (std::out_of_range& e) {
28243       {
28244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28245       };
28246     } catch (std::exception& e) {
28247       {
28248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28249       };
28250     } catch (Dali::DaliException e) {
28251       {
28252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28253       };
28254     } catch (...) {
28255       {
28256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28257       };
28258     }
28259   }
28260
28261   jresult = result;
28262   return jresult;
28263 }
28264
28265
28266 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetInputEnabled(void * jarg1, unsigned int jarg2) {
28267   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28268   bool arg2 ;
28269
28270   arg1 = (Dali::RenderTask *)jarg1;
28271   arg2 = jarg2 ? true : false;
28272   {
28273     try {
28274       (arg1)->SetInputEnabled(arg2);
28275     } catch (std::out_of_range& e) {
28276       {
28277         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28278       };
28279     } catch (std::exception& e) {
28280       {
28281         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28282       };
28283     } catch (Dali::DaliException e) {
28284       {
28285         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28286       };
28287     } catch (...) {
28288       {
28289         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28290       };
28291     }
28292   }
28293
28294 }
28295
28296
28297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetInputEnabled(void * jarg1) {
28298   unsigned int jresult ;
28299   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28300   bool result;
28301
28302   arg1 = (Dali::RenderTask *)jarg1;
28303   {
28304     try {
28305       result = (bool)((Dali::RenderTask const *)arg1)->GetInputEnabled();
28306     } catch (std::out_of_range& e) {
28307       {
28308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28309       };
28310     } catch (std::exception& e) {
28311       {
28312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28313       };
28314     } catch (Dali::DaliException e) {
28315       {
28316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28317       };
28318     } catch (...) {
28319       {
28320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28321       };
28322     }
28323   }
28324
28325   jresult = result;
28326   return jresult;
28327 }
28328
28329
28330 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCameraActor(void * jarg1, void * jarg2) {
28331   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28332   Dali::CameraActor arg2 ;
28333   Dali::CameraActor *argp2 ;
28334
28335   arg1 = (Dali::RenderTask *)jarg1;
28336   argp2 = (Dali::CameraActor *)jarg2;
28337   if (!argp2) {
28338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::CameraActor", 0);
28339     return ;
28340   }
28341   arg2 = *argp2;
28342   {
28343     try {
28344       (arg1)->SetCameraActor(arg2);
28345     } catch (std::out_of_range& e) {
28346       {
28347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28348       };
28349     } catch (std::exception& e) {
28350       {
28351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28352       };
28353     } catch (Dali::DaliException e) {
28354       {
28355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28356       };
28357     } catch (...) {
28358       {
28359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28360       };
28361     }
28362   }
28363
28364 }
28365
28366
28367 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCameraActor(void * jarg1) {
28368   void * jresult ;
28369   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28370   Dali::CameraActor result;
28371
28372   arg1 = (Dali::RenderTask *)jarg1;
28373   {
28374     try {
28375       result = ((Dali::RenderTask const *)arg1)->GetCameraActor();
28376     } catch (std::out_of_range& e) {
28377       {
28378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28379       };
28380     } catch (std::exception& e) {
28381       {
28382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28383       };
28384     } catch (Dali::DaliException e) {
28385       {
28386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28387       };
28388     } catch (...) {
28389       {
28390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28391       };
28392     }
28393   }
28394
28395   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
28396   return jresult;
28397 }
28398
28399
28400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetFrameBuffer(void * jarg1, void * jarg2) {
28401   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28402   Dali::FrameBuffer arg2 ;
28403   Dali::FrameBuffer *argp2 ;
28404
28405   arg1 = (Dali::RenderTask *)jarg1;
28406   argp2 = (Dali::FrameBuffer *)jarg2;
28407   if (!argp2) {
28408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
28409     return ;
28410   }
28411   arg2 = *argp2;
28412   {
28413     try {
28414       (arg1)->SetFrameBuffer(arg2);
28415     } catch (std::out_of_range& e) {
28416       {
28417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28418       };
28419     } catch (std::exception& e) {
28420       {
28421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28422       };
28423     } catch (Dali::DaliException e) {
28424       {
28425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28426       };
28427     } catch (...) {
28428       {
28429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28430       };
28431     }
28432   }
28433
28434 }
28435
28436
28437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetFrameBuffer(void * jarg1) {
28438   void * jresult ;
28439   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28440   Dali::FrameBuffer result;
28441
28442   arg1 = (Dali::RenderTask *)jarg1;
28443   {
28444     try {
28445       result = ((Dali::RenderTask const *)arg1)->GetFrameBuffer();
28446     } catch (std::out_of_range& e) {
28447       {
28448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28449       };
28450     } catch (std::exception& e) {
28451       {
28452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28453       };
28454     } catch (Dali::DaliException e) {
28455       {
28456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28457       };
28458     } catch (...) {
28459       {
28460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28461       };
28462     }
28463   }
28464
28465   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
28466   return jresult;
28467 }
28468
28469
28470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferFunction(void * jarg1, void * jarg2) {
28471   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28472   Dali::RenderTask::ScreenToFrameBufferFunction arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction) 0 ;
28473
28474   arg1 = (Dali::RenderTask *)jarg1;
28475   arg2 = (Dali::RenderTask::ScreenToFrameBufferFunction)jarg2;
28476   {
28477     try {
28478       (arg1)->SetScreenToFrameBufferFunction(arg2);
28479     } catch (std::out_of_range& e) {
28480       {
28481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28482       };
28483     } catch (std::exception& e) {
28484       {
28485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28486       };
28487     } catch (Dali::DaliException e) {
28488       {
28489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28490       };
28491     } catch (...) {
28492       {
28493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28494       };
28495     }
28496   }
28497
28498 }
28499
28500
28501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferFunction(void * jarg1) {
28502   void * jresult ;
28503   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28504   Dali::RenderTask::ScreenToFrameBufferFunction result;
28505
28506   arg1 = (Dali::RenderTask *)jarg1;
28507   {
28508     try {
28509       result = (Dali::RenderTask::ScreenToFrameBufferFunction)((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferFunction();
28510     } catch (std::out_of_range& e) {
28511       {
28512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28513       };
28514     } catch (std::exception& e) {
28515       {
28516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28517       };
28518     } catch (Dali::DaliException e) {
28519       {
28520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28521       };
28522     } catch (...) {
28523       {
28524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28525       };
28526     }
28527   }
28528
28529   jresult = (void *)result;
28530   return jresult;
28531 }
28532
28533
28534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetScreenToFrameBufferMappingActor(void * jarg1, void * jarg2) {
28535   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28536   Dali::Actor arg2 ;
28537   Dali::Actor *argp2 ;
28538
28539   arg1 = (Dali::RenderTask *)jarg1;
28540   argp2 = (Dali::Actor *)jarg2;
28541   if (!argp2) {
28542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
28543     return ;
28544   }
28545   arg2 = *argp2;
28546   {
28547     try {
28548       (arg1)->SetScreenToFrameBufferMappingActor(arg2);
28549     } catch (std::out_of_range& e) {
28550       {
28551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28552       };
28553     } catch (std::exception& e) {
28554       {
28555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28556       };
28557     } catch (Dali::DaliException e) {
28558       {
28559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28560       };
28561     } catch (...) {
28562       {
28563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28564       };
28565     }
28566   }
28567
28568 }
28569
28570
28571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetScreenToFrameBufferMappingActor(void * jarg1) {
28572   void * jresult ;
28573   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28574   Dali::Actor result;
28575
28576   arg1 = (Dali::RenderTask *)jarg1;
28577   {
28578     try {
28579       result = ((Dali::RenderTask const *)arg1)->GetScreenToFrameBufferMappingActor();
28580     } catch (std::out_of_range& e) {
28581       {
28582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28583       };
28584     } catch (std::exception& e) {
28585       {
28586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28587       };
28588     } catch (Dali::DaliException e) {
28589       {
28590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28591       };
28592     } catch (...) {
28593       {
28594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28595       };
28596     }
28597   }
28598
28599   jresult = new Dali::Actor((const Dali::Actor &)result);
28600   return jresult;
28601 }
28602
28603
28604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportPosition(void * jarg1, void * jarg2) {
28605   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28606   Dali::Vector2 arg2 ;
28607   Dali::Vector2 *argp2 ;
28608
28609   arg1 = (Dali::RenderTask *)jarg1;
28610   argp2 = (Dali::Vector2 *)jarg2;
28611   if (!argp2) {
28612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28613     return ;
28614   }
28615   arg2 = *argp2;
28616   {
28617     try {
28618       (arg1)->SetViewportPosition(arg2);
28619     } catch (std::out_of_range& e) {
28620       {
28621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28622       };
28623     } catch (std::exception& e) {
28624       {
28625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28626       };
28627     } catch (Dali::DaliException e) {
28628       {
28629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28630       };
28631     } catch (...) {
28632       {
28633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28634       };
28635     }
28636   }
28637
28638 }
28639
28640
28641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportPosition(void * jarg1) {
28642   void * jresult ;
28643   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28644   Dali::Vector2 result;
28645
28646   arg1 = (Dali::RenderTask *)jarg1;
28647   {
28648     try {
28649       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportPosition();
28650     } catch (std::out_of_range& e) {
28651       {
28652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28653       };
28654     } catch (std::exception& e) {
28655       {
28656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28657       };
28658     } catch (Dali::DaliException e) {
28659       {
28660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28661       };
28662     } catch (...) {
28663       {
28664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28665       };
28666     }
28667   }
28668
28669   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28670   return jresult;
28671 }
28672
28673
28674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewportSize(void * jarg1, void * jarg2) {
28675   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28676   Dali::Vector2 arg2 ;
28677   Dali::Vector2 *argp2 ;
28678
28679   arg1 = (Dali::RenderTask *)jarg1;
28680   argp2 = (Dali::Vector2 *)jarg2;
28681   if (!argp2) {
28682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
28683     return ;
28684   }
28685   arg2 = *argp2;
28686   {
28687     try {
28688       (arg1)->SetViewportSize(arg2);
28689     } catch (std::out_of_range& e) {
28690       {
28691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28692       };
28693     } catch (std::exception& e) {
28694       {
28695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28696       };
28697     } catch (Dali::DaliException e) {
28698       {
28699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28700       };
28701     } catch (...) {
28702       {
28703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28704       };
28705     }
28706   }
28707
28708 }
28709
28710
28711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetCurrentViewportSize(void * jarg1) {
28712   void * jresult ;
28713   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28714   Dali::Vector2 result;
28715
28716   arg1 = (Dali::RenderTask *)jarg1;
28717   {
28718     try {
28719       result = ((Dali::RenderTask const *)arg1)->GetCurrentViewportSize();
28720     } catch (std::out_of_range& e) {
28721       {
28722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28723       };
28724     } catch (std::exception& e) {
28725       {
28726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28727       };
28728     } catch (Dali::DaliException e) {
28729       {
28730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28731       };
28732     } catch (...) {
28733       {
28734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28735       };
28736     }
28737   }
28738
28739   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
28740   return jresult;
28741 }
28742
28743
28744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetViewport(void * jarg1, void * jarg2) {
28745   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28746   Dali::Viewport arg2 ;
28747   Dali::Viewport *argp2 ;
28748
28749   arg1 = (Dali::RenderTask *)jarg1;
28750   argp2 = (Dali::Viewport *)jarg2;
28751   if (!argp2) {
28752     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Viewport", 0);
28753     return ;
28754   }
28755   arg2 = *argp2;
28756   {
28757     try {
28758       (arg1)->SetViewport(arg2);
28759     } catch (std::out_of_range& e) {
28760       {
28761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28762       };
28763     } catch (std::exception& e) {
28764       {
28765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28766       };
28767     } catch (Dali::DaliException e) {
28768       {
28769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28770       };
28771     } catch (...) {
28772       {
28773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28774       };
28775     }
28776   }
28777
28778 }
28779
28780
28781 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetViewport(void * jarg1) {
28782   void * jresult ;
28783   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28784   Dali::Viewport result;
28785
28786   arg1 = (Dali::RenderTask *)jarg1;
28787   {
28788     try {
28789       result = ((Dali::RenderTask const *)arg1)->GetViewport();
28790     } catch (std::out_of_range& e) {
28791       {
28792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28793       };
28794     } catch (std::exception& e) {
28795       {
28796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28797       };
28798     } catch (Dali::DaliException e) {
28799       {
28800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28801       };
28802     } catch (...) {
28803       {
28804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28805       };
28806     }
28807   }
28808
28809   jresult = new Dali::Viewport((const Dali::Viewport &)result);
28810   return jresult;
28811 }
28812
28813
28814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearColor(void * jarg1, void * jarg2) {
28815   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28816   Dali::Vector4 *arg2 = 0 ;
28817
28818   arg1 = (Dali::RenderTask *)jarg1;
28819   arg2 = (Dali::Vector4 *)jarg2;
28820   if (!arg2) {
28821     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
28822     return ;
28823   }
28824   {
28825     try {
28826       (arg1)->SetClearColor((Dali::Vector4 const &)*arg2);
28827     } catch (std::out_of_range& e) {
28828       {
28829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28830       };
28831     } catch (std::exception& e) {
28832       {
28833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28834       };
28835     } catch (Dali::DaliException e) {
28836       {
28837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28838       };
28839     } catch (...) {
28840       {
28841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28842       };
28843     }
28844   }
28845
28846 }
28847
28848
28849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_GetClearColor(void * jarg1) {
28850   void * jresult ;
28851   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28852   Dali::Vector4 result;
28853
28854   arg1 = (Dali::RenderTask *)jarg1;
28855   {
28856     try {
28857       result = ((Dali::RenderTask const *)arg1)->GetClearColor();
28858     } catch (std::out_of_range& e) {
28859       {
28860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28861       };
28862     } catch (std::exception& e) {
28863       {
28864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28865       };
28866     } catch (Dali::DaliException e) {
28867       {
28868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28869       };
28870     } catch (...) {
28871       {
28872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28873       };
28874     }
28875   }
28876
28877   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
28878   return jresult;
28879 }
28880
28881
28882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetClearEnabled(void * jarg1, unsigned int jarg2) {
28883   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28884   bool arg2 ;
28885
28886   arg1 = (Dali::RenderTask *)jarg1;
28887   arg2 = jarg2 ? true : false;
28888   {
28889     try {
28890       (arg1)->SetClearEnabled(arg2);
28891     } catch (std::out_of_range& e) {
28892       {
28893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28894       };
28895     } catch (std::exception& e) {
28896       {
28897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28898       };
28899     } catch (Dali::DaliException e) {
28900       {
28901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28902       };
28903     } catch (...) {
28904       {
28905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28906       };
28907     }
28908   }
28909
28910 }
28911
28912
28913 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetClearEnabled(void * jarg1) {
28914   unsigned int jresult ;
28915   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28916   bool result;
28917
28918   arg1 = (Dali::RenderTask *)jarg1;
28919   {
28920     try {
28921       result = (bool)((Dali::RenderTask const *)arg1)->GetClearEnabled();
28922     } catch (std::out_of_range& e) {
28923       {
28924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28925       };
28926     } catch (std::exception& e) {
28927       {
28928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28929       };
28930     } catch (Dali::DaliException e) {
28931       {
28932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28933       };
28934     } catch (...) {
28935       {
28936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
28937       };
28938     }
28939   }
28940
28941   jresult = result;
28942   return jresult;
28943 }
28944
28945
28946 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetCullMode(void * jarg1, unsigned int jarg2) {
28947   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28948   bool arg2 ;
28949
28950   arg1 = (Dali::RenderTask *)jarg1;
28951   arg2 = jarg2 ? true : false;
28952   {
28953     try {
28954       (arg1)->SetCullMode(arg2);
28955     } catch (std::out_of_range& e) {
28956       {
28957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
28958       };
28959     } catch (std::exception& e) {
28960       {
28961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
28962       };
28963     } catch (Dali::DaliException e) {
28964       {
28965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
28966       };
28967     } catch (...) {
28968       {
28969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
28970       };
28971     }
28972   }
28973
28974 }
28975
28976
28977 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetCullMode(void * jarg1) {
28978   unsigned int jresult ;
28979   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
28980   bool result;
28981
28982   arg1 = (Dali::RenderTask *)jarg1;
28983   {
28984     try {
28985       result = (bool)((Dali::RenderTask const *)arg1)->GetCullMode();
28986     } catch (std::out_of_range& e) {
28987       {
28988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
28989       };
28990     } catch (std::exception& e) {
28991       {
28992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
28993       };
28994     } catch (Dali::DaliException e) {
28995       {
28996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
28997       };
28998     } catch (...) {
28999       {
29000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29001       };
29002     }
29003   }
29004
29005   jresult = result;
29006   return jresult;
29007 }
29008
29009
29010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RenderTask_SetRefreshRate(void * jarg1, unsigned int jarg2) {
29011   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29012   unsigned int arg2 ;
29013
29014   arg1 = (Dali::RenderTask *)jarg1;
29015   arg2 = (unsigned int)jarg2;
29016   {
29017     try {
29018       (arg1)->SetRefreshRate(arg2);
29019     } catch (std::out_of_range& e) {
29020       {
29021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29022       };
29023     } catch (std::exception& e) {
29024       {
29025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29026       };
29027     } catch (Dali::DaliException e) {
29028       {
29029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29030       };
29031     } catch (...) {
29032       {
29033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29034       };
29035     }
29036   }
29037
29038 }
29039
29040
29041 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_GetRefreshRate(void * jarg1) {
29042   unsigned int jresult ;
29043   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29044   unsigned int result;
29045
29046   arg1 = (Dali::RenderTask *)jarg1;
29047   {
29048     try {
29049       result = (unsigned int)((Dali::RenderTask const *)arg1)->GetRefreshRate();
29050     } catch (std::out_of_range& e) {
29051       {
29052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29053       };
29054     } catch (std::exception& e) {
29055       {
29056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29057       };
29058     } catch (Dali::DaliException e) {
29059       {
29060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29061       };
29062     } catch (...) {
29063       {
29064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29065       };
29066     }
29067   }
29068
29069   jresult = result;
29070   return jresult;
29071 }
29072
29073
29074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_WorldToViewport(void * jarg1, void * jarg2, float * jarg3, float * jarg4) {
29075   unsigned int jresult ;
29076   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29077   Dali::Vector3 *arg2 = 0 ;
29078   float *arg3 = 0 ;
29079   float *arg4 = 0 ;
29080   bool result;
29081
29082   arg1 = (Dali::RenderTask *)jarg1;
29083   arg2 = (Dali::Vector3 *)jarg2;
29084   if (!arg2) {
29085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
29086     return 0;
29087   }
29088   arg3 = (float *)jarg3;
29089   arg4 = (float *)jarg4;
29090   {
29091     try {
29092       result = (bool)((Dali::RenderTask const *)arg1)->WorldToViewport((Dali::Vector3 const &)*arg2,*arg3,*arg4);
29093     } catch (std::out_of_range& e) {
29094       {
29095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29096       };
29097     } catch (std::exception& e) {
29098       {
29099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29100       };
29101     } catch (Dali::DaliException e) {
29102       {
29103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29104       };
29105     } catch (...) {
29106       {
29107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29108       };
29109     }
29110   }
29111
29112   jresult = result;
29113   return jresult;
29114 }
29115
29116
29117 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RenderTask_ViewportToLocal(void * jarg1, void * jarg2, float jarg3, float jarg4, float * jarg5, float * jarg6) {
29118   unsigned int jresult ;
29119   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29120   Dali::Actor arg2 ;
29121   float arg3 ;
29122   float arg4 ;
29123   float *arg5 = 0 ;
29124   float *arg6 = 0 ;
29125   Dali::Actor *argp2 ;
29126   bool result;
29127
29128   arg1 = (Dali::RenderTask *)jarg1;
29129   argp2 = (Dali::Actor *)jarg2;
29130   if (!argp2) {
29131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
29132     return 0;
29133   }
29134   arg2 = *argp2;
29135   arg3 = (float)jarg3;
29136   arg4 = (float)jarg4;
29137   arg5 = (float *)jarg5;
29138   arg6 = (float *)jarg6;
29139   {
29140     try {
29141       result = (bool)((Dali::RenderTask const *)arg1)->ViewportToLocal(arg2,arg3,arg4,*arg5,*arg6);
29142     } catch (std::out_of_range& e) {
29143       {
29144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29145       };
29146     } catch (std::exception& e) {
29147       {
29148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29149       };
29150     } catch (Dali::DaliException e) {
29151       {
29152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29153       };
29154     } catch (...) {
29155       {
29156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29157       };
29158     }
29159   }
29160
29161   jresult = result;
29162   return jresult;
29163 }
29164
29165
29166 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RenderTask_FinishedSignal(void * jarg1) {
29167   void * jresult ;
29168   Dali::RenderTask *arg1 = (Dali::RenderTask *) 0 ;
29169   Dali::RenderTask::RenderTaskSignalType *result = 0 ;
29170
29171   arg1 = (Dali::RenderTask *)jarg1;
29172   {
29173     try {
29174       result = (Dali::RenderTask::RenderTaskSignalType *) &(arg1)->FinishedSignal();
29175     } catch (std::out_of_range& e) {
29176       {
29177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29178       };
29179     } catch (std::exception& e) {
29180       {
29181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29182       };
29183     } catch (Dali::DaliException e) {
29184       {
29185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29186       };
29187     } catch (...) {
29188       {
29189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29190       };
29191     }
29192   }
29193
29194   jresult = (void *)result;
29195   return jresult;
29196 }
29197
29198
29199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_0(int jarg1, int jarg2, float jarg3, float jarg4) {
29200   void * jresult ;
29201   int arg1 ;
29202   Dali::TouchPoint::State arg2 ;
29203   float arg3 ;
29204   float arg4 ;
29205   Dali::TouchPoint *result = 0 ;
29206
29207   arg1 = (int)jarg1;
29208   arg2 = (Dali::TouchPoint::State)jarg2;
29209   arg3 = (float)jarg3;
29210   arg4 = (float)jarg4;
29211   {
29212     try {
29213       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4);
29214     } catch (std::out_of_range& e) {
29215       {
29216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29217       };
29218     } catch (std::exception& e) {
29219       {
29220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29221       };
29222     } catch (Dali::DaliException e) {
29223       {
29224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29225       };
29226     } catch (...) {
29227       {
29228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29229       };
29230     }
29231   }
29232
29233   jresult = (void *)result;
29234   return jresult;
29235 }
29236
29237
29238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPoint__SWIG_1(int jarg1, int jarg2, float jarg3, float jarg4, float jarg5, float jarg6) {
29239   void * jresult ;
29240   int arg1 ;
29241   Dali::TouchPoint::State arg2 ;
29242   float arg3 ;
29243   float arg4 ;
29244   float arg5 ;
29245   float arg6 ;
29246   Dali::TouchPoint *result = 0 ;
29247
29248   arg1 = (int)jarg1;
29249   arg2 = (Dali::TouchPoint::State)jarg2;
29250   arg3 = (float)jarg3;
29251   arg4 = (float)jarg4;
29252   arg5 = (float)jarg5;
29253   arg6 = (float)jarg6;
29254   {
29255     try {
29256       result = (Dali::TouchPoint *)new Dali::TouchPoint(arg1,arg2,arg3,arg4,arg5,arg6);
29257     } catch (std::out_of_range& e) {
29258       {
29259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29260       };
29261     } catch (std::exception& e) {
29262       {
29263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29264       };
29265     } catch (Dali::DaliException e) {
29266       {
29267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29268       };
29269     } catch (...) {
29270       {
29271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29272       };
29273     }
29274   }
29275
29276   jresult = (void *)result;
29277   return jresult;
29278 }
29279
29280
29281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPoint(void * jarg1) {
29282   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29283
29284   arg1 = (Dali::TouchPoint *)jarg1;
29285   {
29286     try {
29287       delete arg1;
29288     } catch (std::out_of_range& e) {
29289       {
29290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29291       };
29292     } catch (std::exception& e) {
29293       {
29294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29295       };
29296     } catch (Dali::DaliException e) {
29297       {
29298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29299       };
29300     } catch (...) {
29301       {
29302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29303       };
29304     }
29305   }
29306
29307 }
29308
29309
29310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_set(void * jarg1, int jarg2) {
29311   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29312   int arg2 ;
29313
29314   arg1 = (Dali::TouchPoint *)jarg1;
29315   arg2 = (int)jarg2;
29316   if (arg1) (arg1)->deviceId = arg2;
29317 }
29318
29319
29320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_deviceId_get(void * jarg1) {
29321   int jresult ;
29322   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29323   int result;
29324
29325   arg1 = (Dali::TouchPoint *)jarg1;
29326   result = (int) ((arg1)->deviceId);
29327   jresult = result;
29328   return jresult;
29329 }
29330
29331
29332 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_state_set(void * jarg1, int jarg2) {
29333   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29334   Dali::TouchPoint::State arg2 ;
29335
29336   arg1 = (Dali::TouchPoint *)jarg1;
29337   arg2 = (Dali::TouchPoint::State)jarg2;
29338   if (arg1) (arg1)->state = arg2;
29339 }
29340
29341
29342 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TouchPoint_state_get(void * jarg1) {
29343   int jresult ;
29344   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29345   Dali::TouchPoint::State result;
29346
29347   arg1 = (Dali::TouchPoint *)jarg1;
29348   result = (Dali::TouchPoint::State) ((arg1)->state);
29349   jresult = (int)result;
29350   return jresult;
29351 }
29352
29353
29354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_set(void * jarg1, void * jarg2) {
29355   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29356   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
29357
29358   arg1 = (Dali::TouchPoint *)jarg1;
29359   arg2 = (Dali::Actor *)jarg2;
29360   if (arg1) (arg1)->hitActor = *arg2;
29361 }
29362
29363
29364 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_hitActor_get(void * jarg1) {
29365   void * jresult ;
29366   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29367   Dali::Actor *result = 0 ;
29368
29369   arg1 = (Dali::TouchPoint *)jarg1;
29370   result = (Dali::Actor *)& ((arg1)->hitActor);
29371   jresult = (void *)result;
29372   return jresult;
29373 }
29374
29375
29376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_local_set(void * jarg1, void * jarg2) {
29377   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29378   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29379
29380   arg1 = (Dali::TouchPoint *)jarg1;
29381   arg2 = (Dali::Vector2 *)jarg2;
29382   if (arg1) (arg1)->local = *arg2;
29383 }
29384
29385
29386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_local_get(void * jarg1) {
29387   void * jresult ;
29388   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29389   Dali::Vector2 *result = 0 ;
29390
29391   arg1 = (Dali::TouchPoint *)jarg1;
29392   result = (Dali::Vector2 *)& ((arg1)->local);
29393   jresult = (void *)result;
29394   return jresult;
29395 }
29396
29397
29398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPoint_screen_set(void * jarg1, void * jarg2) {
29399   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29400   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
29401
29402   arg1 = (Dali::TouchPoint *)jarg1;
29403   arg2 = (Dali::Vector2 *)jarg2;
29404   if (arg1) (arg1)->screen = *arg2;
29405 }
29406
29407
29408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPoint_screen_get(void * jarg1) {
29409   void * jresult ;
29410   Dali::TouchPoint *arg1 = (Dali::TouchPoint *) 0 ;
29411   Dali::Vector2 *result = 0 ;
29412
29413   arg1 = (Dali::TouchPoint *)jarg1;
29414   result = (Dali::Vector2 *)& ((arg1)->screen);
29415   jresult = (void *)result;
29416   return jresult;
29417 }
29418
29419
29420 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_0() {
29421   void * jresult ;
29422   Dali::TouchData *result = 0 ;
29423
29424   {
29425     try {
29426       result = (Dali::TouchData *)new Dali::TouchData();
29427     } catch (std::out_of_range& e) {
29428       {
29429         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29430       };
29431     } catch (std::exception& e) {
29432       {
29433         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29434       };
29435     } catch (Dali::DaliException e) {
29436       {
29437         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29438       };
29439     } catch (...) {
29440       {
29441         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29442       };
29443     }
29444   }
29445
29446   jresult = (void *)result;
29447   return jresult;
29448 }
29449
29450
29451 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Touch__SWIG_1(void * jarg1) {
29452   void * jresult ;
29453   Dali::TouchData *arg1 = 0 ;
29454   Dali::TouchData *result = 0 ;
29455
29456   arg1 = (Dali::TouchData *)jarg1;
29457   if (!arg1) {
29458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29459     return 0;
29460   }
29461   {
29462     try {
29463       result = (Dali::TouchData *)new Dali::TouchData((Dali::TouchData const &)*arg1);
29464     } catch (std::out_of_range& e) {
29465       {
29466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29467       };
29468     } catch (std::exception& e) {
29469       {
29470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29471       };
29472     } catch (Dali::DaliException e) {
29473       {
29474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29475       };
29476     } catch (...) {
29477       {
29478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29479       };
29480     }
29481   }
29482
29483   jresult = (void *)result;
29484   return jresult;
29485 }
29486
29487
29488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Touch(void * jarg1) {
29489   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29490
29491   arg1 = (Dali::TouchData *)jarg1;
29492   {
29493     try {
29494       delete arg1;
29495     } catch (std::out_of_range& e) {
29496       {
29497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
29498       };
29499     } catch (std::exception& e) {
29500       {
29501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
29502       };
29503     } catch (Dali::DaliException e) {
29504       {
29505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
29506       };
29507     } catch (...) {
29508       {
29509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
29510       };
29511     }
29512   }
29513
29514 }
29515
29516
29517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_Assign(void * jarg1, void * jarg2) {
29518   void * jresult ;
29519   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29520   Dali::TouchData *arg2 = 0 ;
29521   Dali::TouchData *result = 0 ;
29522
29523   arg1 = (Dali::TouchData *)jarg1;
29524   arg2 = (Dali::TouchData *)jarg2;
29525   if (!arg2) {
29526     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
29527     return 0;
29528   }
29529   {
29530     try {
29531       result = (Dali::TouchData *) &(arg1)->operator =((Dali::TouchData const &)*arg2);
29532     } catch (std::out_of_range& e) {
29533       {
29534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29535       };
29536     } catch (std::exception& e) {
29537       {
29538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29539       };
29540     } catch (Dali::DaliException e) {
29541       {
29542         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29543       };
29544     } catch (...) {
29545       {
29546         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29547       };
29548     }
29549   }
29550
29551   jresult = (void *)result;
29552   return jresult;
29553 }
29554
29555
29556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetTime(void * jarg1) {
29557   unsigned long jresult ;
29558   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29559   unsigned long result;
29560
29561   arg1 = (Dali::TouchData *)jarg1;
29562   {
29563     try {
29564       result = (unsigned long)((Dali::TouchData const *)arg1)->GetTime();
29565     } catch (std::out_of_range& e) {
29566       {
29567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29568       };
29569     } catch (std::exception& e) {
29570       {
29571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29572       };
29573     } catch (Dali::DaliException e) {
29574       {
29575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29576       };
29577     } catch (...) {
29578       {
29579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29580       };
29581     }
29582   }
29583
29584   jresult = (unsigned long)result;
29585   return jresult;
29586 }
29587
29588
29589 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Touch_GetPointCount(void * jarg1) {
29590   unsigned long jresult ;
29591   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29592   std::size_t result;
29593
29594   arg1 = (Dali::TouchData *)jarg1;
29595   {
29596     try {
29597       result = ((Dali::TouchData const *)arg1)->GetPointCount();
29598     } catch (std::out_of_range& e) {
29599       {
29600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29601       };
29602     } catch (std::exception& e) {
29603       {
29604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29605       };
29606     } catch (Dali::DaliException e) {
29607       {
29608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29609       };
29610     } catch (...) {
29611       {
29612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29613       };
29614     }
29615   }
29616
29617   jresult = (unsigned long)result;
29618   return jresult;
29619 }
29620
29621
29622 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetDeviceId(void * jarg1, unsigned long jarg2) {
29623   int jresult ;
29624   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29625   std::size_t arg2 ;
29626   int32_t result;
29627
29628   arg1 = (Dali::TouchData *)jarg1;
29629   arg2 = (std::size_t)jarg2;
29630   {
29631     try {
29632       result = ((Dali::TouchData const *)arg1)->GetDeviceId(arg2);
29633     } catch (std::out_of_range& e) {
29634       {
29635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29636       };
29637     } catch (std::exception& e) {
29638       {
29639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29640       };
29641     } catch (Dali::DaliException e) {
29642       {
29643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29644       };
29645     } catch (...) {
29646       {
29647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29648       };
29649     }
29650   }
29651
29652   jresult = result;
29653   return jresult;
29654 }
29655
29656
29657 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetState(void * jarg1, unsigned long jarg2) {
29658   int jresult ;
29659   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29660   std::size_t arg2 ;
29661   Dali::PointState::Type result;
29662
29663   arg1 = (Dali::TouchData *)jarg1;
29664   arg2 = (std::size_t)jarg2;
29665   {
29666     try {
29667       result = (Dali::PointState::Type)((Dali::TouchData const *)arg1)->GetState(arg2);
29668     } catch (std::out_of_range& e) {
29669       {
29670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29671       };
29672     } catch (std::exception& e) {
29673       {
29674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29675       };
29676     } catch (Dali::DaliException e) {
29677       {
29678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29679       };
29680     } catch (...) {
29681       {
29682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29683       };
29684     }
29685   }
29686
29687   jresult = (int)result;
29688   return jresult;
29689 }
29690
29691
29692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetHitActor(void * jarg1, unsigned long jarg2) {
29693   void * jresult ;
29694   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29695   std::size_t arg2 ;
29696   Dali::Actor result;
29697
29698   arg1 = (Dali::TouchData *)jarg1;
29699   arg2 = (std::size_t)jarg2;
29700   {
29701     try {
29702       result = ((Dali::TouchData const *)arg1)->GetHitActor(arg2);
29703     } catch (std::out_of_range& e) {
29704       {
29705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29706       };
29707     } catch (std::exception& e) {
29708       {
29709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29710       };
29711     } catch (Dali::DaliException e) {
29712       {
29713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29714       };
29715     } catch (...) {
29716       {
29717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29718       };
29719     }
29720   }
29721
29722   jresult = new Dali::Actor((const Dali::Actor &)result);
29723   return jresult;
29724 }
29725
29726
29727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetLocalPosition(void * jarg1, unsigned long jarg2) {
29728   void * jresult ;
29729   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29730   std::size_t arg2 ;
29731   Dali::Vector2 *result = 0 ;
29732
29733   arg1 = (Dali::TouchData *)jarg1;
29734   arg2 = (std::size_t)jarg2;
29735   {
29736     try {
29737       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetLocalPosition(arg2);
29738     } catch (std::out_of_range& e) {
29739       {
29740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29741       };
29742     } catch (std::exception& e) {
29743       {
29744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29745       };
29746     } catch (Dali::DaliException e) {
29747       {
29748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29749       };
29750     } catch (...) {
29751       {
29752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29753       };
29754     }
29755   }
29756
29757   jresult = (void *)result;
29758   return jresult;
29759 }
29760
29761
29762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetScreenPosition(void * jarg1, unsigned long jarg2) {
29763   void * jresult ;
29764   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29765   std::size_t arg2 ;
29766   Dali::Vector2 *result = 0 ;
29767
29768   arg1 = (Dali::TouchData *)jarg1;
29769   arg2 = (std::size_t)jarg2;
29770   {
29771     try {
29772       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetScreenPosition(arg2);
29773     } catch (std::out_of_range& e) {
29774       {
29775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29776       };
29777     } catch (std::exception& e) {
29778       {
29779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29780       };
29781     } catch (Dali::DaliException e) {
29782       {
29783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29784       };
29785     } catch (...) {
29786       {
29787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29788       };
29789     }
29790   }
29791
29792   jresult = (void *)result;
29793   return jresult;
29794 }
29795
29796
29797 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetRadius(void * jarg1, unsigned long jarg2) {
29798   float jresult ;
29799   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29800   std::size_t arg2 ;
29801   float result;
29802
29803   arg1 = (Dali::TouchData *)jarg1;
29804   arg2 = (std::size_t)jarg2;
29805   {
29806     try {
29807       result = (float)((Dali::TouchData const *)arg1)->GetRadius(arg2);
29808     } catch (std::out_of_range& e) {
29809       {
29810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29811       };
29812     } catch (std::exception& e) {
29813       {
29814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29815       };
29816     } catch (Dali::DaliException e) {
29817       {
29818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29819       };
29820     } catch (...) {
29821       {
29822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29823       };
29824     }
29825   }
29826
29827   jresult = result;
29828   return jresult;
29829 }
29830
29831
29832 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetEllipseRadius(void * jarg1, unsigned long jarg2) {
29833   void * jresult ;
29834   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29835   std::size_t arg2 ;
29836   Dali::Vector2 *result = 0 ;
29837
29838   arg1 = (Dali::TouchData *)jarg1;
29839   arg2 = (std::size_t)jarg2;
29840   {
29841     try {
29842       result = (Dali::Vector2 *) &((Dali::TouchData const *)arg1)->GetEllipseRadius(arg2);
29843     } catch (std::out_of_range& e) {
29844       {
29845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29846       };
29847     } catch (std::exception& e) {
29848       {
29849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29850       };
29851     } catch (Dali::DaliException e) {
29852       {
29853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29854       };
29855     } catch (...) {
29856       {
29857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29858       };
29859     }
29860   }
29861
29862   jresult = (void *)result;
29863   return jresult;
29864 }
29865
29866
29867 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Touch_GetPressure(void * jarg1, unsigned long jarg2) {
29868   float jresult ;
29869   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29870   std::size_t arg2 ;
29871   float result;
29872
29873   arg1 = (Dali::TouchData *)jarg1;
29874   arg2 = (std::size_t)jarg2;
29875   {
29876     try {
29877       result = (float)((Dali::TouchData const *)arg1)->GetPressure(arg2);
29878     } catch (std::out_of_range& e) {
29879       {
29880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29881       };
29882     } catch (std::exception& e) {
29883       {
29884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29885       };
29886     } catch (Dali::DaliException e) {
29887       {
29888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29889       };
29890     } catch (...) {
29891       {
29892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29893       };
29894     }
29895   }
29896
29897   jresult = result;
29898   return jresult;
29899 }
29900
29901
29902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Touch_GetAngle(void * jarg1, unsigned long jarg2) {
29903   void * jresult ;
29904   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29905   std::size_t arg2 ;
29906   Dali::Degree result;
29907
29908   arg1 = (Dali::TouchData *)jarg1;
29909   arg2 = (std::size_t)jarg2;
29910   {
29911     try {
29912       result = ((Dali::TouchData const *)arg1)->GetAngle(arg2);
29913     } catch (std::out_of_range& e) {
29914       {
29915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29916       };
29917     } catch (std::exception& e) {
29918       {
29919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29920       };
29921     } catch (Dali::DaliException e) {
29922       {
29923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29924       };
29925     } catch (...) {
29926       {
29927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29928       };
29929     }
29930   }
29931
29932   jresult = new Dali::Degree((const Dali::Degree &)result);
29933   return jresult;
29934 }
29935
29936
29937 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Touch_GetMouseButton(void * jarg1, unsigned long jarg2) {
29938   int jresult ;
29939   Dali::TouchData *arg1 = (Dali::TouchData *) 0 ;
29940   std::size_t arg2 ;
29941   Dali::MouseButton::Type result;
29942
29943   arg1 = (Dali::TouchData *)jarg1;
29944   arg2 = (std::size_t)jarg2;
29945   {
29946     try {
29947       result = ((Dali::TouchData const *)arg1)->GetMouseButton(arg2);
29948     } catch (std::out_of_range& e) {
29949       {
29950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29951       };
29952     } catch (std::exception& e) {
29953       {
29954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29955       };
29956     } catch (Dali::DaliException e) {
29957       {
29958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29959       };
29960     } catch (...) {
29961       {
29962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29963       };
29964     }
29965   }
29966
29967   jresult = static_cast< int >(result);
29968   return jresult;
29969 }
29970
29971
29972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_0() {
29973   void * jresult ;
29974   Dali::GestureDetector *result = 0 ;
29975
29976   {
29977     try {
29978       result = (Dali::GestureDetector *)new Dali::GestureDetector();
29979     } catch (std::out_of_range& e) {
29980       {
29981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
29982       };
29983     } catch (std::exception& e) {
29984       {
29985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
29986       };
29987     } catch (Dali::DaliException e) {
29988       {
29989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
29990       };
29991     } catch (...) {
29992       {
29993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
29994       };
29995     }
29996   }
29997
29998   jresult = (void *)result;
29999   return jresult;
30000 }
30001
30002
30003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_DownCast(void * jarg1) {
30004   void * jresult ;
30005   Dali::BaseHandle arg1 ;
30006   Dali::BaseHandle *argp1 ;
30007   Dali::GestureDetector result;
30008
30009   argp1 = (Dali::BaseHandle *)jarg1;
30010   if (!argp1) {
30011     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
30012     return 0;
30013   }
30014   arg1 = *argp1;
30015   {
30016     try {
30017       result = Dali::GestureDetector::DownCast(arg1);
30018     } catch (std::out_of_range& e) {
30019       {
30020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30021       };
30022     } catch (std::exception& e) {
30023       {
30024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30025       };
30026     } catch (Dali::DaliException e) {
30027       {
30028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30029       };
30030     } catch (...) {
30031       {
30032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30033       };
30034     }
30035   }
30036
30037   jresult = new Dali::GestureDetector((const Dali::GestureDetector &)result);
30038   return jresult;
30039 }
30040
30041
30042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GestureDetector(void * jarg1) {
30043   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30044
30045   arg1 = (Dali::GestureDetector *)jarg1;
30046   {
30047     try {
30048       delete arg1;
30049     } catch (std::out_of_range& e) {
30050       {
30051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30052       };
30053     } catch (std::exception& e) {
30054       {
30055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30056       };
30057     } catch (Dali::DaliException e) {
30058       {
30059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30060       };
30061     } catch (...) {
30062       {
30063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30064       };
30065     }
30066   }
30067
30068 }
30069
30070
30071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GestureDetector__SWIG_1(void * jarg1) {
30072   void * jresult ;
30073   Dali::GestureDetector *arg1 = 0 ;
30074   Dali::GestureDetector *result = 0 ;
30075
30076   arg1 = (Dali::GestureDetector *)jarg1;
30077   if (!arg1) {
30078     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30079     return 0;
30080   }
30081   {
30082     try {
30083       result = (Dali::GestureDetector *)new Dali::GestureDetector((Dali::GestureDetector const &)*arg1);
30084     } catch (std::out_of_range& e) {
30085       {
30086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30087       };
30088     } catch (std::exception& e) {
30089       {
30090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30091       };
30092     } catch (Dali::DaliException e) {
30093       {
30094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30095       };
30096     } catch (...) {
30097       {
30098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30099       };
30100     }
30101   }
30102
30103   jresult = (void *)result;
30104   return jresult;
30105 }
30106
30107
30108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_Assign(void * jarg1, void * jarg2) {
30109   void * jresult ;
30110   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30111   Dali::GestureDetector *arg2 = 0 ;
30112   Dali::GestureDetector *result = 0 ;
30113
30114   arg1 = (Dali::GestureDetector *)jarg1;
30115   arg2 = (Dali::GestureDetector *)jarg2;
30116   if (!arg2) {
30117     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::GestureDetector const & type is null", 0);
30118     return 0;
30119   }
30120   {
30121     try {
30122       result = (Dali::GestureDetector *) &(arg1)->operator =((Dali::GestureDetector const &)*arg2);
30123     } catch (std::out_of_range& e) {
30124       {
30125         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30126       };
30127     } catch (std::exception& e) {
30128       {
30129         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30130       };
30131     } catch (Dali::DaliException e) {
30132       {
30133         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30134       };
30135     } catch (...) {
30136       {
30137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30138       };
30139     }
30140   }
30141
30142   jresult = (void *)result;
30143   return jresult;
30144 }
30145
30146
30147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Attach(void * jarg1, void * jarg2) {
30148   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30149   Dali::Actor arg2 ;
30150   Dali::Actor *argp2 ;
30151
30152   arg1 = (Dali::GestureDetector *)jarg1;
30153   argp2 = (Dali::Actor *)jarg2;
30154   if (!argp2) {
30155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30156     return ;
30157   }
30158   arg2 = *argp2;
30159   {
30160     try {
30161       (arg1)->Attach(arg2);
30162     } catch (std::out_of_range& e) {
30163       {
30164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30165       };
30166     } catch (std::exception& e) {
30167       {
30168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30169       };
30170     } catch (Dali::DaliException e) {
30171       {
30172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30173       };
30174     } catch (...) {
30175       {
30176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30177       };
30178     }
30179   }
30180
30181 }
30182
30183
30184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_Detach(void * jarg1, void * jarg2) {
30185   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30186   Dali::Actor arg2 ;
30187   Dali::Actor *argp2 ;
30188
30189   arg1 = (Dali::GestureDetector *)jarg1;
30190   argp2 = (Dali::Actor *)jarg2;
30191   if (!argp2) {
30192     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
30193     return ;
30194   }
30195   arg2 = *argp2;
30196   {
30197     try {
30198       (arg1)->Detach(arg2);
30199     } catch (std::out_of_range& e) {
30200       {
30201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30202       };
30203     } catch (std::exception& e) {
30204       {
30205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30206       };
30207     } catch (Dali::DaliException e) {
30208       {
30209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30210       };
30211     } catch (...) {
30212       {
30213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30214       };
30215     }
30216   }
30217
30218 }
30219
30220
30221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GestureDetector_DetachAll(void * jarg1) {
30222   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30223
30224   arg1 = (Dali::GestureDetector *)jarg1;
30225   {
30226     try {
30227       (arg1)->DetachAll();
30228     } catch (std::out_of_range& e) {
30229       {
30230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30231       };
30232     } catch (std::exception& e) {
30233       {
30234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30235       };
30236     } catch (Dali::DaliException e) {
30237       {
30238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30239       };
30240     } catch (...) {
30241       {
30242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30243       };
30244     }
30245   }
30246
30247 }
30248
30249
30250 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActorCount(void * jarg1) {
30251   unsigned long jresult ;
30252   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30253   size_t result;
30254
30255   arg1 = (Dali::GestureDetector *)jarg1;
30256   {
30257     try {
30258       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActorCount();
30259     } catch (std::out_of_range& e) {
30260       {
30261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30262       };
30263     } catch (std::exception& e) {
30264       {
30265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30266       };
30267     } catch (Dali::DaliException e) {
30268       {
30269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30270       };
30271     } catch (...) {
30272       {
30273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30274       };
30275     }
30276   }
30277
30278   jresult = (unsigned long)result;
30279   return jresult;
30280 }
30281
30282
30283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GestureDetector_GetAttachedActor(void * jarg1, unsigned long jarg2) {
30284   void * jresult ;
30285   Dali::GestureDetector *arg1 = (Dali::GestureDetector *) 0 ;
30286   size_t arg2 ;
30287   Dali::Actor result;
30288
30289   arg1 = (Dali::GestureDetector *)jarg1;
30290   arg2 = (size_t)jarg2;
30291   {
30292     try {
30293       result = ((Dali::GestureDetector const *)arg1)->GetAttachedActor(arg2);
30294     } catch (std::out_of_range& e) {
30295       {
30296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30297       };
30298     } catch (std::exception& e) {
30299       {
30300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30301       };
30302     } catch (Dali::DaliException e) {
30303       {
30304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30305       };
30306     } catch (...) {
30307       {
30308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30309       };
30310     }
30311   }
30312
30313   jresult = new Dali::Actor((const Dali::Actor &)result);
30314   return jresult;
30315 }
30316
30317
30318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Gesture(void * jarg1) {
30319   void * jresult ;
30320   Dali::Gesture *arg1 = 0 ;
30321   Dali::Gesture *result = 0 ;
30322
30323   arg1 = (Dali::Gesture *)jarg1;
30324   if (!arg1) {
30325     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30326     return 0;
30327   }
30328   {
30329     try {
30330       result = (Dali::Gesture *)new Dali::Gesture((Dali::Gesture const &)*arg1);
30331     } catch (std::out_of_range& e) {
30332       {
30333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30334       };
30335     } catch (std::exception& e) {
30336       {
30337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30338       };
30339     } catch (Dali::DaliException e) {
30340       {
30341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30342       };
30343     } catch (...) {
30344       {
30345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30346       };
30347     }
30348   }
30349
30350   jresult = (void *)result;
30351   return jresult;
30352 }
30353
30354
30355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Gesture_Assign(void * jarg1, void * jarg2) {
30356   void * jresult ;
30357   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30358   Dali::Gesture *arg2 = 0 ;
30359   Dali::Gesture *result = 0 ;
30360
30361   arg1 = (Dali::Gesture *)jarg1;
30362   arg2 = (Dali::Gesture *)jarg2;
30363   if (!arg2) {
30364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Gesture const & type is null", 0);
30365     return 0;
30366   }
30367   {
30368     try {
30369       result = (Dali::Gesture *) &(arg1)->operator =((Dali::Gesture const &)*arg2);
30370     } catch (std::out_of_range& e) {
30371       {
30372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30373       };
30374     } catch (std::exception& e) {
30375       {
30376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30377       };
30378     } catch (Dali::DaliException e) {
30379       {
30380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30381       };
30382     } catch (...) {
30383       {
30384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30385       };
30386     }
30387   }
30388
30389   jresult = (void *)result;
30390   return jresult;
30391 }
30392
30393
30394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Gesture(void * jarg1) {
30395   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30396
30397   arg1 = (Dali::Gesture *)jarg1;
30398   {
30399     try {
30400       delete arg1;
30401     } catch (std::out_of_range& e) {
30402       {
30403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30404       };
30405     } catch (std::exception& e) {
30406       {
30407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30408       };
30409     } catch (Dali::DaliException e) {
30410       {
30411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30412       };
30413     } catch (...) {
30414       {
30415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30416       };
30417     }
30418   }
30419
30420 }
30421
30422
30423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_type_set(void * jarg1, int jarg2) {
30424   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30425   Dali::Gesture::Type arg2 ;
30426
30427   arg1 = (Dali::Gesture *)jarg1;
30428   arg2 = (Dali::Gesture::Type)jarg2;
30429   if (arg1) (arg1)->type = arg2;
30430 }
30431
30432
30433 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_type_get(void * jarg1) {
30434   int jresult ;
30435   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30436   Dali::Gesture::Type result;
30437
30438   arg1 = (Dali::Gesture *)jarg1;
30439   result = (Dali::Gesture::Type) ((arg1)->type);
30440   jresult = (int)result;
30441   return jresult;
30442 }
30443
30444
30445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_state_set(void * jarg1, int jarg2) {
30446   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30447   Dali::Gesture::State arg2 ;
30448
30449   arg1 = (Dali::Gesture *)jarg1;
30450   arg2 = (Dali::Gesture::State)jarg2;
30451   if (arg1) (arg1)->state = arg2;
30452 }
30453
30454
30455 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Gesture_state_get(void * jarg1) {
30456   int jresult ;
30457   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30458   Dali::Gesture::State result;
30459
30460   arg1 = (Dali::Gesture *)jarg1;
30461   result = (Dali::Gesture::State) ((arg1)->state);
30462   jresult = (int)result;
30463   return jresult;
30464 }
30465
30466
30467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Gesture_time_set(void * jarg1, unsigned int jarg2) {
30468   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30469   unsigned int arg2 ;
30470
30471   arg1 = (Dali::Gesture *)jarg1;
30472   arg2 = (unsigned int)jarg2;
30473   if (arg1) (arg1)->time = arg2;
30474 }
30475
30476
30477 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Gesture_time_get(void * jarg1) {
30478   unsigned int jresult ;
30479   Dali::Gesture *arg1 = (Dali::Gesture *) 0 ;
30480   unsigned int result;
30481
30482   arg1 = (Dali::Gesture *)jarg1;
30483   result = (unsigned int) ((arg1)->time);
30484   jresult = result;
30485   return jresult;
30486 }
30487
30488
30489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_0() {
30490   void * jresult ;
30491   Dali::HoverEvent *result = 0 ;
30492
30493   {
30494     try {
30495       result = (Dali::HoverEvent *)new Dali::HoverEvent();
30496     } catch (std::out_of_range& e) {
30497       {
30498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30499       };
30500     } catch (std::exception& e) {
30501       {
30502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30503       };
30504     } catch (Dali::DaliException e) {
30505       {
30506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30507       };
30508     } catch (...) {
30509       {
30510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30511       };
30512     }
30513   }
30514
30515   jresult = (void *)result;
30516   return jresult;
30517 }
30518
30519
30520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Hover__SWIG_1(unsigned long jarg1) {
30521   void * jresult ;
30522   unsigned long arg1 ;
30523   Dali::HoverEvent *result = 0 ;
30524
30525   arg1 = (unsigned long)jarg1;
30526   {
30527     try {
30528       result = (Dali::HoverEvent *)new Dali::HoverEvent(arg1);
30529     } catch (std::out_of_range& e) {
30530       {
30531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30532       };
30533     } catch (std::exception& e) {
30534       {
30535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30536       };
30537     } catch (Dali::DaliException e) {
30538       {
30539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30540       };
30541     } catch (...) {
30542       {
30543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30544       };
30545     }
30546   }
30547
30548   jresult = (void *)result;
30549   return jresult;
30550 }
30551
30552
30553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Hover(void * jarg1) {
30554   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30555
30556   arg1 = (Dali::HoverEvent *)jarg1;
30557   {
30558     try {
30559       delete arg1;
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_Hover_points_set(void * jarg1, void * jarg2) {
30583   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30584   Dali::TouchPointContainer *arg2 = (Dali::TouchPointContainer *) 0 ;
30585
30586   arg1 = (Dali::HoverEvent *)jarg1;
30587   arg2 = (Dali::TouchPointContainer *)jarg2;
30588   if (arg1) (arg1)->points = *arg2;
30589 }
30590
30591
30592 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_points_get(void * jarg1) {
30593   void * jresult ;
30594   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30595   Dali::TouchPointContainer *result = 0 ;
30596
30597   arg1 = (Dali::HoverEvent *)jarg1;
30598   result = (Dali::TouchPointContainer *)& ((arg1)->points);
30599   jresult = (void *)result;
30600   return jresult;
30601 }
30602
30603
30604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Hover_time_set(void * jarg1, unsigned long jarg2) {
30605   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30606   unsigned long arg2 ;
30607
30608   arg1 = (Dali::HoverEvent *)jarg1;
30609   arg2 = (unsigned long)jarg2;
30610   if (arg1) (arg1)->time = arg2;
30611 }
30612
30613
30614 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Hover_time_get(void * jarg1) {
30615   unsigned long jresult ;
30616   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30617   unsigned long result;
30618
30619   arg1 = (Dali::HoverEvent *)jarg1;
30620   result = (unsigned long) ((arg1)->time);
30621   jresult = (unsigned long)result;
30622   return jresult;
30623 }
30624
30625
30626 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Hover_GetPointCount(void * jarg1) {
30627   unsigned int jresult ;
30628   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30629   unsigned int result;
30630
30631   arg1 = (Dali::HoverEvent *)jarg1;
30632   {
30633     try {
30634       result = (unsigned int)((Dali::HoverEvent const *)arg1)->GetPointCount();
30635     } catch (std::out_of_range& e) {
30636       {
30637         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30638       };
30639     } catch (std::exception& e) {
30640       {
30641         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30642       };
30643     } catch (Dali::DaliException e) {
30644       {
30645         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30646       };
30647     } catch (...) {
30648       {
30649         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30650       };
30651     }
30652   }
30653
30654   jresult = result;
30655   return jresult;
30656 }
30657
30658
30659 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Hover_GetPoint(void * jarg1, unsigned int jarg2) {
30660   void * jresult ;
30661   Dali::HoverEvent *arg1 = (Dali::HoverEvent *) 0 ;
30662   unsigned int arg2 ;
30663   Dali::TouchPoint *result = 0 ;
30664
30665   arg1 = (Dali::HoverEvent *)jarg1;
30666   arg2 = (unsigned int)jarg2;
30667   {
30668     try {
30669       result = (Dali::TouchPoint *) &((Dali::HoverEvent const *)arg1)->GetPoint(arg2);
30670     } catch (std::out_of_range& e) {
30671       {
30672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30673       };
30674     } catch (std::exception& e) {
30675       {
30676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30677       };
30678     } catch (Dali::DaliException e) {
30679       {
30680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30681       };
30682     } catch (...) {
30683       {
30684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30685       };
30686     }
30687   }
30688
30689   jresult = (void *)result;
30690   return jresult;
30691 }
30692
30693
30694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_0() {
30695   void * jresult ;
30696   Dali::KeyEvent *result = 0 ;
30697
30698   {
30699     try {
30700       result = (Dali::KeyEvent *)new Dali::KeyEvent();
30701     } catch (std::out_of_range& e) {
30702       {
30703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30704       };
30705     } catch (std::exception& e) {
30706       {
30707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30708       };
30709     } catch (Dali::DaliException e) {
30710       {
30711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30712       };
30713     } catch (...) {
30714       {
30715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30716       };
30717     }
30718   }
30719
30720   jresult = (void *)result;
30721   return jresult;
30722 }
30723
30724
30725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_1(char * jarg1, char * jarg2, int jarg3, int jarg4, unsigned long jarg5, int jarg6) {
30726   void * jresult ;
30727   std::string *arg1 = 0 ;
30728   std::string *arg2 = 0 ;
30729   int arg3 ;
30730   int arg4 ;
30731   unsigned long arg5 ;
30732   Dali::KeyEvent::State *arg6 = 0 ;
30733   Dali::KeyEvent::State temp6 ;
30734   Dali::KeyEvent *result = 0 ;
30735
30736   if (!jarg1) {
30737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30738     return 0;
30739   }
30740   std::string arg1_str(jarg1);
30741   arg1 = &arg1_str;
30742   if (!jarg2) {
30743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30744     return 0;
30745   }
30746   std::string arg2_str(jarg2);
30747   arg2 = &arg2_str;
30748   arg3 = (int)jarg3;
30749   arg4 = (int)jarg4;
30750   arg5 = (unsigned long)jarg5;
30751   temp6 = (Dali::KeyEvent::State)jarg6;
30752   arg6 = &temp6;
30753   {
30754     try {
30755       result = (Dali::KeyEvent *)new Dali::KeyEvent((std::string const &)*arg1,(std::string const &)*arg2,arg3,arg4,arg5,(Dali::KeyEvent::State const &)*arg6);
30756     } catch (std::out_of_range& e) {
30757       {
30758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30759       };
30760     } catch (std::exception& e) {
30761       {
30762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30763       };
30764     } catch (Dali::DaliException e) {
30765       {
30766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30767       };
30768     } catch (...) {
30769       {
30770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30771       };
30772     }
30773   }
30774
30775   jresult = (void *)result;
30776
30777   //argout typemap for const std::string&
30778
30779
30780   //argout typemap for const std::string&
30781
30782   return jresult;
30783 }
30784
30785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Key__SWIG_2(void * jarg1) {
30786   void * jresult ;
30787   Dali::KeyEvent *arg1 = 0 ;
30788   Dali::KeyEvent *result = 0 ;
30789
30790   arg1 = (Dali::KeyEvent *)jarg1;
30791   if (!arg1) {
30792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30793     return 0;
30794   }
30795   {
30796     try {
30797       result = (Dali::KeyEvent *)new Dali::KeyEvent((Dali::KeyEvent const &)*arg1);
30798     } catch (std::out_of_range& e) {
30799       {
30800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30801       };
30802     } catch (std::exception& e) {
30803       {
30804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30805       };
30806     } catch (Dali::DaliException e) {
30807       {
30808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30809       };
30810     } catch (...) {
30811       {
30812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30813       };
30814     }
30815   }
30816
30817   jresult = (void *)result;
30818   return jresult;
30819 }
30820
30821
30822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Key_Assign(void * jarg1, void * jarg2) {
30823   void * jresult ;
30824   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30825   Dali::KeyEvent *arg2 = 0 ;
30826   Dali::KeyEvent *result = 0 ;
30827
30828   arg1 = (Dali::KeyEvent *)jarg1;
30829   arg2 = (Dali::KeyEvent *)jarg2;
30830   if (!arg2) {
30831     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
30832     return 0;
30833   }
30834   {
30835     try {
30836       result = (Dali::KeyEvent *) &(arg1)->operator =((Dali::KeyEvent const &)*arg2);
30837     } catch (std::out_of_range& e) {
30838       {
30839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30840       };
30841     } catch (std::exception& e) {
30842       {
30843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30844       };
30845     } catch (Dali::DaliException e) {
30846       {
30847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30848       };
30849     } catch (...) {
30850       {
30851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30852       };
30853     }
30854   }
30855
30856   jresult = (void *)result;
30857   return jresult;
30858 }
30859
30860
30861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Key(void * jarg1) {
30862   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30863
30864   arg1 = (Dali::KeyEvent *)jarg1;
30865   {
30866     try {
30867       delete arg1;
30868     } catch (std::out_of_range& e) {
30869       {
30870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
30871       };
30872     } catch (std::exception& e) {
30873       {
30874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
30875       };
30876     } catch (Dali::DaliException e) {
30877       {
30878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
30879       };
30880     } catch (...) {
30881       {
30882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
30883       };
30884     }
30885   }
30886
30887 }
30888
30889
30890 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsShiftModifier(void * jarg1) {
30891   unsigned int jresult ;
30892   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30893   bool result;
30894
30895   arg1 = (Dali::KeyEvent *)jarg1;
30896   {
30897     try {
30898       result = (bool)((Dali::KeyEvent const *)arg1)->IsShiftModifier();
30899     } catch (std::out_of_range& e) {
30900       {
30901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30902       };
30903     } catch (std::exception& e) {
30904       {
30905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30906       };
30907     } catch (Dali::DaliException e) {
30908       {
30909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30910       };
30911     } catch (...) {
30912       {
30913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30914       };
30915     }
30916   }
30917
30918   jresult = result;
30919   return jresult;
30920 }
30921
30922
30923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsCtrlModifier(void * jarg1) {
30924   unsigned int jresult ;
30925   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30926   bool result;
30927
30928   arg1 = (Dali::KeyEvent *)jarg1;
30929   {
30930     try {
30931       result = (bool)((Dali::KeyEvent const *)arg1)->IsCtrlModifier();
30932     } catch (std::out_of_range& e) {
30933       {
30934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30935       };
30936     } catch (std::exception& e) {
30937       {
30938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30939       };
30940     } catch (Dali::DaliException e) {
30941       {
30942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30943       };
30944     } catch (...) {
30945       {
30946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30947       };
30948     }
30949   }
30950
30951   jresult = result;
30952   return jresult;
30953 }
30954
30955
30956 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Key_IsAltModifier(void * jarg1) {
30957   unsigned int jresult ;
30958   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30959   bool result;
30960
30961   arg1 = (Dali::KeyEvent *)jarg1;
30962   {
30963     try {
30964       result = (bool)((Dali::KeyEvent const *)arg1)->IsAltModifier();
30965     } catch (std::out_of_range& e) {
30966       {
30967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
30968       };
30969     } catch (std::exception& e) {
30970       {
30971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
30972       };
30973     } catch (Dali::DaliException e) {
30974       {
30975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
30976       };
30977     } catch (...) {
30978       {
30979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
30980       };
30981     }
30982   }
30983
30984   jresult = result;
30985   return jresult;
30986 }
30987
30988
30989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressedName_set(void * jarg1, char * jarg2) {
30990   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
30991   std::string *arg2 = 0 ;
30992
30993   arg1 = (Dali::KeyEvent *)jarg1;
30994   if (!jarg2) {
30995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
30996     return ;
30997   }
30998   std::string arg2_str(jarg2);
30999   arg2 = &arg2_str;
31000   if (arg1) (arg1)->keyPressedName = *arg2;
31001
31002   //argout typemap for const std::string&
31003
31004 }
31005
31006
31007 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressedName_get(void * jarg1) {
31008   char * jresult ;
31009
31010   if( jarg1 == NULL )
31011   {
31012     jresult = SWIG_csharp_string_callback( "" );
31013   }
31014   else
31015   {
31016     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31017     std::string *result = 0;
31018
31019     arg1 = ( Dali::KeyEvent * )jarg1;
31020     result = ( std::string * ) & ( ( arg1 )->keyPressedName );
31021     jresult = SWIG_csharp_string_callback( result->c_str() );
31022   }
31023
31024   return jresult;
31025 }
31026
31027
31028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyPressed_set(void * jarg1, char * jarg2) {
31029   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31030   std::string *arg2 = 0 ;
31031
31032   arg1 = (Dali::KeyEvent *)jarg1;
31033   if (!jarg2) {
31034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
31035     return ;
31036   }
31037   std::string arg2_str(jarg2);
31038   arg2 = &arg2_str;
31039   if (arg1) (arg1)->keyPressed = *arg2;
31040
31041   //argout typemap for const std::string&
31042
31043 }
31044
31045
31046 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_keyPressed_get(void * jarg1) {
31047   char * jresult ;
31048   if( NULL == jarg1 )
31049   {
31050     jresult = SWIG_csharp_string_callback( "" );
31051   }
31052   else
31053   {
31054     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31055     std::string *result = 0;
31056
31057     arg1 = ( Dali::KeyEvent * )jarg1;
31058     result = ( std::string * ) & ( ( arg1 )->keyPressed );
31059     jresult = SWIG_csharp_string_callback( result->c_str() );
31060   }
31061   return jresult;
31062 }
31063
31064
31065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyCode_set(void * jarg1, int jarg2) {
31066   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31067   int arg2 ;
31068
31069   arg1 = (Dali::KeyEvent *)jarg1;
31070   arg2 = (int)jarg2;
31071   if (arg1) (arg1)->keyCode = arg2;
31072 }
31073
31074
31075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyCode_get(void * jarg1) {
31076   int jresult ;
31077   if( NULL == jarg1 )
31078   {
31079     jresult = -1;
31080   }
31081   else
31082   {
31083     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31084     int result;
31085
31086     arg1 = ( Dali::KeyEvent * )jarg1;
31087     result = (int)( ( arg1 )->keyCode );
31088     jresult = result;
31089   }
31090   return jresult;
31091 }
31092
31093
31094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_keyModifier_set(void * jarg1, int jarg2) {
31095   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31096   int arg2 ;
31097
31098   arg1 = (Dali::KeyEvent *)jarg1;
31099   arg2 = (int)jarg2;
31100   if (arg1) (arg1)->keyModifier = arg2;
31101 }
31102
31103
31104 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_keyModifier_get(void * jarg1) {
31105   int jresult ;
31106   if( jarg1 == NULL )
31107   {
31108     jresult = -1;
31109   }
31110   else
31111   {
31112     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31113     int result;
31114
31115     arg1 = ( Dali::KeyEvent * )jarg1;
31116     result = (int)( ( arg1 )->keyModifier );
31117     jresult = result;
31118   }
31119   return jresult;
31120 }
31121
31122
31123 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_time_set(void * jarg1, unsigned long jarg2) {
31124   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31125   unsigned long arg2 ;
31126
31127   arg1 = (Dali::KeyEvent *)jarg1;
31128   arg2 = (unsigned long)jarg2;
31129   if (arg1) (arg1)->time = arg2;
31130 }
31131
31132
31133 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Key_time_get(void * jarg1) {
31134   unsigned long jresult ;
31135   if( jarg1 == NULL )
31136   {
31137     jresult = 0;
31138   }
31139   else
31140   {
31141     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31142     unsigned long result;
31143
31144     arg1 = ( Dali::KeyEvent * )jarg1;
31145     result = (unsigned long)( ( arg1 )->time );
31146     jresult = (unsigned long)result;
31147   }
31148   return jresult;
31149 }
31150
31151
31152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Key_state_set(void * jarg1, int jarg2) {
31153   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0 ;
31154   Dali::KeyEvent::State arg2 ;
31155
31156   arg1 = (Dali::KeyEvent *)jarg1;
31157   arg2 = (Dali::KeyEvent::State)jarg2;
31158   if (arg1) (arg1)->state = arg2;
31159 }
31160
31161
31162 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Key_state_get(void * jarg1) {
31163   int jresult ;
31164   if( jarg1 == NULL )
31165   {
31166     jresult = -1;
31167   }
31168   else
31169   {
31170     Dali::KeyEvent *arg1 = ( Dali::KeyEvent * ) 0;
31171     Dali::KeyEvent::State result;
31172
31173     arg1 = ( Dali::KeyEvent * )jarg1;
31174     result = ( Dali::KeyEvent::State ) ( ( arg1 )->state );
31175     jresult = (int)result;
31176   }
31177   return jresult;
31178 }
31179
31180 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Key_logicalKey_get(void * jarg1) {
31181   char * jresult ;
31182   std::string result;
31183   Dali::KeyEvent *arg1 = (Dali::KeyEvent *) 0;
31184
31185   arg1 = (Dali::KeyEvent *)jarg1;
31186   if (!arg1) {
31187     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::DevelKeyEvent const & type is null", 0);
31188     return 0;
31189   }
31190   {
31191     try {
31192       result = Dali::DevelKeyEvent::GetLogicalKey(*arg1);
31193     } catch (std::out_of_range& e) {
31194       {
31195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31196       };
31197     } catch (std::exception& e) {
31198       {
31199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31200       };
31201     } catch (Dali::DaliException e) {
31202       {
31203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31204       };
31205     } catch (...) {
31206       {
31207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31208       };
31209     }
31210
31211   }
31212
31213   jresult = SWIG_csharp_string_callback( (&result)->c_str() );
31214   return jresult;
31215 }
31216
31217
31218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_0() {
31219   void * jresult ;
31220   Dali::LongPressGestureDetector *result = 0 ;
31221
31222   {
31223     try {
31224       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector();
31225     } catch (std::out_of_range& e) {
31226       {
31227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31228       };
31229     } catch (std::exception& e) {
31230       {
31231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31232       };
31233     } catch (Dali::DaliException e) {
31234       {
31235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31236       };
31237     } catch (...) {
31238       {
31239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31240       };
31241     }
31242   }
31243
31244   jresult = (void *)result;
31245   return jresult;
31246 }
31247
31248
31249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_0() {
31250   void * jresult ;
31251   Dali::LongPressGestureDetector result;
31252
31253   {
31254     try {
31255       result = Dali::LongPressGestureDetector::New();
31256     } catch (std::out_of_range& e) {
31257       {
31258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31259       };
31260     } catch (std::exception& e) {
31261       {
31262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31263       };
31264     } catch (Dali::DaliException e) {
31265       {
31266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31267       };
31268     } catch (...) {
31269       {
31270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31271       };
31272     }
31273   }
31274
31275   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31276   return jresult;
31277 }
31278
31279
31280 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_1(unsigned int jarg1) {
31281   void * jresult ;
31282   unsigned int arg1 ;
31283   Dali::LongPressGestureDetector result;
31284
31285   arg1 = (unsigned int)jarg1;
31286   {
31287     try {
31288       result = Dali::LongPressGestureDetector::New(arg1);
31289     } catch (std::out_of_range& e) {
31290       {
31291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31292       };
31293     } catch (std::exception& e) {
31294       {
31295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31296       };
31297     } catch (Dali::DaliException e) {
31298       {
31299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31300       };
31301     } catch (...) {
31302       {
31303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31304       };
31305     }
31306   }
31307
31308   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31309   return jresult;
31310 }
31311
31312
31313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_New__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
31314   void * jresult ;
31315   unsigned int arg1 ;
31316   unsigned int arg2 ;
31317   Dali::LongPressGestureDetector result;
31318
31319   arg1 = (unsigned int)jarg1;
31320   arg2 = (unsigned int)jarg2;
31321   {
31322     try {
31323       result = Dali::LongPressGestureDetector::New(arg1,arg2);
31324     } catch (std::out_of_range& e) {
31325       {
31326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31327       };
31328     } catch (std::exception& e) {
31329       {
31330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31331       };
31332     } catch (Dali::DaliException e) {
31333       {
31334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31335       };
31336     } catch (...) {
31337       {
31338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31339       };
31340     }
31341   }
31342
31343   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31344   return jresult;
31345 }
31346
31347
31348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DownCast(void * jarg1) {
31349   void * jresult ;
31350   Dali::BaseHandle arg1 ;
31351   Dali::BaseHandle *argp1 ;
31352   Dali::LongPressGestureDetector result;
31353
31354   argp1 = (Dali::BaseHandle *)jarg1;
31355   if (!argp1) {
31356     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
31357     return 0;
31358   }
31359   arg1 = *argp1;
31360   {
31361     try {
31362       result = Dali::LongPressGestureDetector::DownCast(arg1);
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 = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
31383   return jresult;
31384 }
31385
31386
31387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetector(void * jarg1) {
31388   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31389
31390   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31391   {
31392     try {
31393       delete arg1;
31394     } catch (std::out_of_range& e) {
31395       {
31396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31397       };
31398     } catch (std::exception& e) {
31399       {
31400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31401       };
31402     } catch (Dali::DaliException e) {
31403       {
31404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31405       };
31406     } catch (...) {
31407       {
31408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31409       };
31410     }
31411   }
31412
31413 }
31414
31415
31416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetector__SWIG_1(void * jarg1) {
31417   void * jresult ;
31418   Dali::LongPressGestureDetector *arg1 = 0 ;
31419   Dali::LongPressGestureDetector *result = 0 ;
31420
31421   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31422   if (!arg1) {
31423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31424     return 0;
31425   }
31426   {
31427     try {
31428       result = (Dali::LongPressGestureDetector *)new Dali::LongPressGestureDetector((Dali::LongPressGestureDetector const &)*arg1);
31429     } catch (std::out_of_range& e) {
31430       {
31431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31432       };
31433     } catch (std::exception& e) {
31434       {
31435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31436       };
31437     } catch (Dali::DaliException e) {
31438       {
31439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31440       };
31441     } catch (...) {
31442       {
31443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31444       };
31445     }
31446   }
31447
31448   jresult = (void *)result;
31449   return jresult;
31450 }
31451
31452
31453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_Assign(void * jarg1, void * jarg2) {
31454   void * jresult ;
31455   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31456   Dali::LongPressGestureDetector *arg2 = 0 ;
31457   Dali::LongPressGestureDetector *result = 0 ;
31458
31459   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31460   arg2 = (Dali::LongPressGestureDetector *)jarg2;
31461   if (!arg2) {
31462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGestureDetector const & type is null", 0);
31463     return 0;
31464   }
31465   {
31466     try {
31467       result = (Dali::LongPressGestureDetector *) &(arg1)->operator =((Dali::LongPressGestureDetector const &)*arg2);
31468     } catch (std::out_of_range& e) {
31469       {
31470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31471       };
31472     } catch (std::exception& e) {
31473       {
31474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31475       };
31476     } catch (Dali::DaliException e) {
31477       {
31478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31479       };
31480     } catch (...) {
31481       {
31482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31483       };
31484     }
31485   }
31486
31487   jresult = (void *)result;
31488   return jresult;
31489 }
31490
31491
31492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_0(void * jarg1, unsigned int jarg2) {
31493   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31494   unsigned int arg2 ;
31495
31496   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31497   arg2 = (unsigned int)jarg2;
31498   {
31499     try {
31500       (arg1)->SetTouchesRequired(arg2);
31501     } catch (std::out_of_range& e) {
31502       {
31503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31504       };
31505     } catch (std::exception& e) {
31506       {
31507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31508       };
31509     } catch (Dali::DaliException e) {
31510       {
31511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31512       };
31513     } catch (...) {
31514       {
31515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31516       };
31517     }
31518   }
31519
31520 }
31521
31522
31523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SetTouchesRequired__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
31524   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31525   unsigned int arg2 ;
31526   unsigned int arg3 ;
31527
31528   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31529   arg2 = (unsigned int)jarg2;
31530   arg3 = (unsigned int)jarg3;
31531   {
31532     try {
31533       (arg1)->SetTouchesRequired(arg2,arg3);
31534     } catch (std::out_of_range& e) {
31535       {
31536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31537       };
31538     } catch (std::exception& e) {
31539       {
31540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31541       };
31542     } catch (Dali::DaliException e) {
31543       {
31544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31545       };
31546     } catch (...) {
31547       {
31548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31549       };
31550     }
31551   }
31552
31553 }
31554
31555
31556 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
31557   unsigned int jresult ;
31558   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31559   unsigned int result;
31560
31561   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31562   {
31563     try {
31564       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMinimumTouchesRequired();
31565     } catch (std::out_of_range& e) {
31566       {
31567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31568       };
31569     } catch (std::exception& e) {
31570       {
31571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31572       };
31573     } catch (Dali::DaliException e) {
31574       {
31575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31576       };
31577     } catch (...) {
31578       {
31579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31580       };
31581     }
31582   }
31583
31584   jresult = result;
31585   return jresult;
31586 }
31587
31588
31589 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
31590   unsigned int jresult ;
31591   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31592   unsigned int result;
31593
31594   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31595   {
31596     try {
31597       result = (unsigned int)((Dali::LongPressGestureDetector const *)arg1)->GetMaximumTouchesRequired();
31598     } catch (std::out_of_range& e) {
31599       {
31600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31601       };
31602     } catch (std::exception& e) {
31603       {
31604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31605       };
31606     } catch (Dali::DaliException e) {
31607       {
31608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31609       };
31610     } catch (...) {
31611       {
31612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31613       };
31614     }
31615   }
31616
31617   jresult = result;
31618   return jresult;
31619 }
31620
31621
31622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_DetectedSignal(void * jarg1) {
31623   void * jresult ;
31624   Dali::LongPressGestureDetector *arg1 = (Dali::LongPressGestureDetector *) 0 ;
31625   Dali::LongPressGestureDetector::DetectedSignalType *result = 0 ;
31626
31627   arg1 = (Dali::LongPressGestureDetector *)jarg1;
31628   {
31629     try {
31630       result = (Dali::LongPressGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
31631     } catch (std::out_of_range& e) {
31632       {
31633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31634       };
31635     } catch (std::exception& e) {
31636       {
31637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31638       };
31639     } catch (Dali::DaliException e) {
31640       {
31641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31642       };
31643     } catch (...) {
31644       {
31645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31646       };
31647     }
31648   }
31649
31650   jresult = (void *)result;
31651   return jresult;
31652 }
31653
31654
31655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_0(int jarg1) {
31656   void * jresult ;
31657   Dali::Gesture::State arg1 ;
31658   Dali::LongPressGesture *result = 0 ;
31659
31660   arg1 = (Dali::Gesture::State)jarg1;
31661   {
31662     try {
31663       result = (Dali::LongPressGesture *)new Dali::LongPressGesture(arg1);
31664     } catch (std::out_of_range& e) {
31665       {
31666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31667       };
31668     } catch (std::exception& e) {
31669       {
31670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31671       };
31672     } catch (Dali::DaliException e) {
31673       {
31674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31675       };
31676     } catch (...) {
31677       {
31678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31679       };
31680     }
31681   }
31682
31683   jresult = (void *)result;
31684   return jresult;
31685 }
31686
31687
31688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGesture__SWIG_1(void * jarg1) {
31689   void * jresult ;
31690   Dali::LongPressGesture *arg1 = 0 ;
31691   Dali::LongPressGesture *result = 0 ;
31692
31693   arg1 = (Dali::LongPressGesture *)jarg1;
31694   if (!arg1) {
31695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31696     return 0;
31697   }
31698   {
31699     try {
31700       result = (Dali::LongPressGesture *)new Dali::LongPressGesture((Dali::LongPressGesture const &)*arg1);
31701     } catch (std::out_of_range& e) {
31702       {
31703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31704       };
31705     } catch (std::exception& e) {
31706       {
31707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31708       };
31709     } catch (Dali::DaliException e) {
31710       {
31711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31712       };
31713     } catch (...) {
31714       {
31715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31716       };
31717     }
31718   }
31719
31720   jresult = (void *)result;
31721   return jresult;
31722 }
31723
31724
31725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_Assign(void * jarg1, void * jarg2) {
31726   void * jresult ;
31727   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31728   Dali::LongPressGesture *arg2 = 0 ;
31729   Dali::LongPressGesture *result = 0 ;
31730
31731   arg1 = (Dali::LongPressGesture *)jarg1;
31732   arg2 = (Dali::LongPressGesture *)jarg2;
31733   if (!arg2) {
31734     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
31735     return 0;
31736   }
31737   {
31738     try {
31739       result = (Dali::LongPressGesture *) &(arg1)->operator =((Dali::LongPressGesture const &)*arg2);
31740     } catch (std::out_of_range& e) {
31741       {
31742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31743       };
31744     } catch (std::exception& e) {
31745       {
31746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31747       };
31748     } catch (Dali::DaliException e) {
31749       {
31750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31751       };
31752     } catch (...) {
31753       {
31754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31755       };
31756     }
31757   }
31758
31759   jresult = (void *)result;
31760   return jresult;
31761 }
31762
31763
31764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGesture(void * jarg1) {
31765   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31766
31767   arg1 = (Dali::LongPressGesture *)jarg1;
31768   {
31769     try {
31770       delete arg1;
31771     } catch (std::out_of_range& e) {
31772       {
31773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31774       };
31775     } catch (std::exception& e) {
31776       {
31777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31778       };
31779     } catch (Dali::DaliException e) {
31780       {
31781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31782       };
31783     } catch (...) {
31784       {
31785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31786       };
31787     }
31788   }
31789
31790 }
31791
31792
31793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
31794   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31795   unsigned int arg2 ;
31796
31797   arg1 = (Dali::LongPressGesture *)jarg1;
31798   arg2 = (unsigned int)jarg2;
31799   if (arg1) (arg1)->numberOfTouches = arg2;
31800 }
31801
31802
31803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGesture_numberOfTouches_get(void * jarg1) {
31804   unsigned int jresult ;
31805   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31806   unsigned int result;
31807
31808   arg1 = (Dali::LongPressGesture *)jarg1;
31809   result = (unsigned int) ((arg1)->numberOfTouches);
31810   jresult = result;
31811   return jresult;
31812 }
31813
31814
31815 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_set(void * jarg1, void * jarg2) {
31816   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31817   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31818
31819   arg1 = (Dali::LongPressGesture *)jarg1;
31820   arg2 = (Dali::Vector2 *)jarg2;
31821   if (arg1) (arg1)->screenPoint = *arg2;
31822 }
31823
31824
31825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_screenPoint_get(void * jarg1) {
31826   void * jresult ;
31827   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31828   Dali::Vector2 *result = 0 ;
31829
31830   arg1 = (Dali::LongPressGesture *)jarg1;
31831   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
31832   jresult = (void *)result;
31833   return jresult;
31834 }
31835
31836
31837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_set(void * jarg1, void * jarg2) {
31838   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31839   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
31840
31841   arg1 = (Dali::LongPressGesture *)jarg1;
31842   arg2 = (Dali::Vector2 *)jarg2;
31843   if (arg1) (arg1)->localPoint = *arg2;
31844 }
31845
31846
31847 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LongPressGesture_localPoint_get(void * jarg1) {
31848   void * jresult ;
31849   Dali::LongPressGesture *arg1 = (Dali::LongPressGesture *) 0 ;
31850   Dali::Vector2 *result = 0 ;
31851
31852   arg1 = (Dali::LongPressGesture *)jarg1;
31853   result = (Dali::Vector2 *)& ((arg1)->localPoint);
31854   jresult = (void *)result;
31855   return jresult;
31856 }
31857
31858
31859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Wheel__SWIG_0() {
31860   void * jresult ;
31861   Dali::WheelEvent *result = 0 ;
31862
31863   {
31864     try {
31865       result = (Dali::WheelEvent *)new Dali::WheelEvent();
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_new_Wheel__SWIG_1(int jarg1, int jarg2, unsigned int jarg3, void * jarg4, int jarg5, unsigned int jarg6) {
31891   void * jresult ;
31892   Dali::WheelEvent::Type arg1 ;
31893   int arg2 ;
31894   unsigned int arg3 ;
31895   Dali::Vector2 arg4 ;
31896   int arg5 ;
31897   unsigned int arg6 ;
31898   Dali::Vector2 *argp4 ;
31899   Dali::WheelEvent *result = 0 ;
31900
31901   arg1 = (Dali::WheelEvent::Type)jarg1;
31902   arg2 = (int)jarg2;
31903   arg3 = (unsigned int)jarg3;
31904   argp4 = (Dali::Vector2 *)jarg4;
31905   if (!argp4) {
31906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
31907     return 0;
31908   }
31909   arg4 = *argp4;
31910   arg5 = (int)jarg5;
31911   arg6 = (unsigned int)jarg6;
31912   {
31913     try {
31914       result = (Dali::WheelEvent *)new Dali::WheelEvent(arg1,arg2,arg3,arg4,arg5,arg6);
31915     } catch (std::out_of_range& e) {
31916       {
31917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31918       };
31919     } catch (std::exception& e) {
31920       {
31921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31922       };
31923     } catch (Dali::DaliException e) {
31924       {
31925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31926       };
31927     } catch (...) {
31928       {
31929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31930       };
31931     }
31932   }
31933
31934   jresult = (void *)result;
31935   return jresult;
31936 }
31937
31938
31939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Wheel(void * jarg1) {
31940   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31941
31942   arg1 = (Dali::WheelEvent *)jarg1;
31943   {
31944     try {
31945       delete arg1;
31946     } catch (std::out_of_range& e) {
31947       {
31948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
31949       };
31950     } catch (std::exception& e) {
31951       {
31952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
31953       };
31954     } catch (Dali::DaliException e) {
31955       {
31956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
31957       };
31958     } catch (...) {
31959       {
31960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
31961       };
31962     }
31963   }
31964
31965 }
31966
31967
31968 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsShiftModifier(void * jarg1) {
31969   unsigned int jresult ;
31970   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
31971   bool result;
31972
31973   arg1 = (Dali::WheelEvent *)jarg1;
31974   {
31975     try {
31976       result = (bool)((Dali::WheelEvent const *)arg1)->IsShiftModifier();
31977     } catch (std::out_of_range& e) {
31978       {
31979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
31980       };
31981     } catch (std::exception& e) {
31982       {
31983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
31984       };
31985     } catch (Dali::DaliException e) {
31986       {
31987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
31988       };
31989     } catch (...) {
31990       {
31991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
31992       };
31993     }
31994   }
31995
31996   jresult = result;
31997   return jresult;
31998 }
31999
32000
32001 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsCtrlModifier(void * jarg1) {
32002   unsigned int jresult ;
32003   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32004   bool result;
32005
32006   arg1 = (Dali::WheelEvent *)jarg1;
32007   {
32008     try {
32009       result = (bool)((Dali::WheelEvent const *)arg1)->IsCtrlModifier();
32010     } catch (std::out_of_range& e) {
32011       {
32012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32013       };
32014     } catch (std::exception& e) {
32015       {
32016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32017       };
32018     } catch (Dali::DaliException e) {
32019       {
32020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32021       };
32022     } catch (...) {
32023       {
32024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32025       };
32026     }
32027   }
32028
32029   jresult = result;
32030   return jresult;
32031 }
32032
32033
32034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_IsAltModifier(void * jarg1) {
32035   unsigned int jresult ;
32036   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32037   bool result;
32038
32039   arg1 = (Dali::WheelEvent *)jarg1;
32040   {
32041     try {
32042       result = (bool)((Dali::WheelEvent const *)arg1)->IsAltModifier();
32043     } catch (std::out_of_range& e) {
32044       {
32045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32046       };
32047     } catch (std::exception& e) {
32048       {
32049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32050       };
32051     } catch (Dali::DaliException e) {
32052       {
32053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32054       };
32055     } catch (...) {
32056       {
32057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32058       };
32059     }
32060   }
32061
32062   jresult = result;
32063   return jresult;
32064 }
32065
32066
32067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_type_set(void * jarg1, int jarg2) {
32068   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32069   Dali::WheelEvent::Type arg2 ;
32070
32071   arg1 = (Dali::WheelEvent *)jarg1;
32072   arg2 = (Dali::WheelEvent::Type)jarg2;
32073   if (arg1) (arg1)->type = arg2;
32074 }
32075
32076
32077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_type_get(void * jarg1) {
32078   int jresult ;
32079   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32080   Dali::WheelEvent::Type result;
32081
32082   arg1 = (Dali::WheelEvent *)jarg1;
32083   result = (Dali::WheelEvent::Type) ((arg1)->type);
32084   jresult = (int)result;
32085   return jresult;
32086 }
32087
32088
32089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_direction_set(void * jarg1, int jarg2) {
32090   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32091   int arg2 ;
32092
32093   arg1 = (Dali::WheelEvent *)jarg1;
32094   arg2 = (int)jarg2;
32095   if (arg1) (arg1)->direction = arg2;
32096 }
32097
32098
32099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_direction_get(void * jarg1) {
32100   int jresult ;
32101   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32102   int result;
32103
32104   arg1 = (Dali::WheelEvent *)jarg1;
32105   result = (int) ((arg1)->direction);
32106   jresult = result;
32107   return jresult;
32108 }
32109
32110
32111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_modifiers_set(void * jarg1, unsigned int jarg2) {
32112   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32113   unsigned int arg2 ;
32114
32115   arg1 = (Dali::WheelEvent *)jarg1;
32116   arg2 = (unsigned int)jarg2;
32117   if (arg1) (arg1)->modifiers = arg2;
32118 }
32119
32120
32121 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_modifiers_get(void * jarg1) {
32122   unsigned int jresult ;
32123   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32124   unsigned int result;
32125
32126   arg1 = (Dali::WheelEvent *)jarg1;
32127   result = (unsigned int) ((arg1)->modifiers);
32128   jresult = result;
32129   return jresult;
32130 }
32131
32132
32133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_point_set(void * jarg1, void * jarg2) {
32134   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32135   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
32136
32137   arg1 = (Dali::WheelEvent *)jarg1;
32138   arg2 = (Dali::Vector2 *)jarg2;
32139   if (arg1) (arg1)->point = *arg2;
32140 }
32141
32142
32143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Wheel_point_get(void * jarg1) {
32144   void * jresult ;
32145   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32146   Dali::Vector2 *result = 0 ;
32147
32148   arg1 = (Dali::WheelEvent *)jarg1;
32149   result = (Dali::Vector2 *)& ((arg1)->point);
32150   jresult = (void *)result;
32151   return jresult;
32152 }
32153
32154
32155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_z_set(void * jarg1, int jarg2) {
32156   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32157   int arg2 ;
32158
32159   arg1 = (Dali::WheelEvent *)jarg1;
32160   arg2 = (int)jarg2;
32161   if (arg1) (arg1)->z = arg2;
32162 }
32163
32164
32165 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Wheel_z_get(void * jarg1) {
32166   int jresult ;
32167   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32168   int result;
32169
32170   arg1 = (Dali::WheelEvent *)jarg1;
32171   result = (int) ((arg1)->z);
32172   jresult = result;
32173   return jresult;
32174 }
32175
32176
32177 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_set(void * jarg1, unsigned int jarg2) {
32178   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32179   unsigned int arg2 ;
32180
32181   arg1 = (Dali::WheelEvent *)jarg1;
32182   arg2 = (unsigned int)jarg2;
32183   if (arg1) (arg1)->timeStamp = arg2;
32184 }
32185
32186
32187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Wheel_timeStamp_get(void * jarg1) {
32188   unsigned int jresult ;
32189   Dali::WheelEvent *arg1 = (Dali::WheelEvent *) 0 ;
32190   unsigned int result;
32191
32192   arg1 = (Dali::WheelEvent *)jarg1;
32193   result = (unsigned int) ((arg1)->timeStamp);
32194   jresult = result;
32195   return jresult;
32196 }
32197
32198 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetDeviceName(void * jarg1) {
32199   char * jresult ;
32200   Dali::KeyEvent *arg1 = 0 ;
32201   std::string result;
32202
32203   arg1 = (Dali::KeyEvent *)jarg1;
32204   if (!arg1) {
32205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32206     return 0;
32207   }
32208   {
32209     try {
32210       result = arg1->GetDeviceName();
32211     } catch (std::out_of_range& e) {
32212       {
32213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32214       };
32215     } catch (std::exception& e) {
32216       {
32217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32218       };
32219     } catch (Dali::DaliException e) {
32220       {
32221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32222       };
32223     } catch (...) {
32224       {
32225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32226       };
32227     }
32228   }
32229
32230   jresult = SWIG_csharp_string_callback((&result)->c_str());
32231   return jresult;
32232 }
32233
32234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceClass(void * jarg1) {
32235   int jresult ;
32236   Dali::KeyEvent *arg1 = 0 ;
32237   Dali::Device::Class::Type result;
32238
32239   arg1 = (Dali::KeyEvent *)jarg1;
32240   if (!arg1) {
32241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32242     return 0;
32243   }
32244   {
32245     try {
32246       result = (Dali::Device::Class::Type)arg1->GetDeviceClass();
32247     } catch (std::out_of_range& e) {
32248       {
32249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32250       };
32251     } catch (std::exception& e) {
32252       {
32253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32254       };
32255     } catch (Dali::DaliException e) {
32256       {
32257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32258       };
32259     } catch (...) {
32260       {
32261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32262       };
32263     }
32264   }
32265
32266   jresult = (int)result;
32267   return jresult;
32268 }
32269
32270 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GetDeviceSubClass(void * jarg1) {
32271   int jresult ;
32272   Dali::KeyEvent *arg1 = 0 ;
32273   Dali::Device::Subclass::Type result;
32274
32275   arg1 = (Dali::KeyEvent *)jarg1;
32276   if (!arg1) {
32277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
32278     return 0;
32279   }
32280   {
32281     try {
32282       result = (Dali::Device::Subclass::Type)arg1->GetDeviceSubclass();
32283     } catch (std::out_of_range& e) {
32284       {
32285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32286       };
32287     } catch (std::exception& e) {
32288       {
32289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32290       };
32291     } catch (Dali::DaliException e) {
32292       {
32293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32294       };
32295     } catch (...) {
32296       {
32297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32298       };
32299     }
32300   }
32301
32302   jresult = (int)result;
32303   return jresult;
32304 }
32305
32306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Raise(void * jarg1) {
32307   Dali::Actor arg1 ;
32308   Dali::Actor *argp1 ;
32309
32310   argp1 = (Dali::Actor *)jarg1;
32311   if (!argp1) {
32312     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32313     return ;
32314   }
32315   arg1 = *argp1;
32316   {
32317     try {
32318       arg1.Raise();
32319     } catch (std::out_of_range& e) {
32320       {
32321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32322       };
32323     } catch (std::exception& e) {
32324       {
32325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32326       };
32327     } catch (Dali::DaliException e) {
32328       {
32329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32330       };
32331     } catch (...) {
32332       {
32333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32334       };
32335     }
32336   }
32337
32338 }
32339
32340
32341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Lower(void * jarg1) {
32342   Dali::Actor arg1 ;
32343   Dali::Actor *argp1 ;
32344
32345   argp1 = (Dali::Actor *)jarg1;
32346   if (!argp1) {
32347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32348     return ;
32349   }
32350   arg1 = *argp1;
32351   {
32352     try {
32353       arg1.Lower();
32354     } catch (std::out_of_range& e) {
32355       {
32356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32357       };
32358     } catch (std::exception& e) {
32359       {
32360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32361       };
32362     } catch (Dali::DaliException e) {
32363       {
32364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32365       };
32366     } catch (...) {
32367       {
32368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32369       };
32370     }
32371   }
32372
32373 }
32374
32375
32376 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseToTop(void * jarg1) {
32377   Dali::Actor arg1 ;
32378   Dali::Actor *argp1 ;
32379
32380   argp1 = (Dali::Actor *)jarg1;
32381   if (!argp1) {
32382     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32383     return ;
32384   }
32385   arg1 = *argp1;
32386   {
32387     try {
32388       arg1.RaiseToTop();
32389     } catch (std::out_of_range& e) {
32390       {
32391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32392       };
32393     } catch (std::exception& e) {
32394       {
32395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32396       };
32397     } catch (Dali::DaliException e) {
32398       {
32399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32400       };
32401     } catch (...) {
32402       {
32403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32404       };
32405     }
32406   }
32407
32408 }
32409
32410
32411 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerToBottom(void * jarg1) {
32412   Dali::Actor arg1 ;
32413   Dali::Actor *argp1 ;
32414
32415   argp1 = (Dali::Actor *)jarg1;
32416   if (!argp1) {
32417     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32418     return ;
32419   }
32420   arg1 = *argp1;
32421   {
32422     try {
32423       arg1.LowerToBottom();
32424     } catch (std::out_of_range& e) {
32425       {
32426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32427       };
32428     } catch (std::exception& e) {
32429       {
32430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32431       };
32432     } catch (Dali::DaliException e) {
32433       {
32434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32435       };
32436     } catch (...) {
32437       {
32438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32439       };
32440     }
32441   }
32442
32443 }
32444
32445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RaiseAbove(void * jarg1, void * jarg2) {
32446   Dali::Actor arg1 ;
32447   Dali::Actor arg2 ;
32448   Dali::Actor *argp1 ;
32449   Dali::Actor *argp2 ;
32450
32451   argp1 = (Dali::Actor *)jarg1;
32452   if (!argp1) {
32453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32454     return ;
32455   }
32456   arg1 = *argp1;
32457   argp2 = (Dali::Actor *)jarg2;
32458   if (!argp2) {
32459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32460     return ;
32461   }
32462   arg2 = *argp2;
32463   {
32464     try {
32465       arg1.RaiseAbove(arg2);
32466     } catch (std::out_of_range& e) {
32467       {
32468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32469       };
32470     } catch (std::exception& e) {
32471       {
32472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32473       };
32474     } catch (Dali::DaliException e) {
32475       {
32476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32477       };
32478     } catch (...) {
32479       {
32480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32481       };
32482     }
32483   }
32484
32485 }
32486
32487
32488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LowerBelow(void * jarg1, void * jarg2) {
32489   Dali::Actor arg1 ;
32490   Dali::Actor arg2 ;
32491   Dali::Actor *argp1 ;
32492   Dali::Actor *argp2 ;
32493
32494   argp1 = (Dali::Actor *)jarg1;
32495   if (!argp1) {
32496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32497     return ;
32498   }
32499   arg1 = *argp1;
32500   argp2 = (Dali::Actor *)jarg2;
32501   if (!argp2) {
32502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32503     return ;
32504   }
32505   arg2 = *argp2;
32506   {
32507     try {
32508       arg1.LowerBelow(arg2);
32509     } catch (std::out_of_range& e) {
32510       {
32511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
32512       };
32513     } catch (std::exception& e) {
32514       {
32515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
32516       };
32517     } catch (Dali::DaliException e) {
32518       {
32519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
32520       };
32521     } catch (...) {
32522       {
32523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
32524       };
32525     }
32526   }
32527
32528 }
32529
32530
32531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisibilityChangedSignal(void * jarg1) {
32532   void * jresult ;
32533   Dali::Actor arg1 ;
32534   Dali::Actor *argp1 ;
32535   Dali::DevelActor::VisibilityChangedSignalType *result = 0 ;
32536
32537   argp1 = (Dali::Actor *)jarg1;
32538   if (!argp1) {
32539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
32540     return 0;
32541   }
32542   arg1 = *argp1;
32543   {
32544     try {
32545       result = (Dali::DevelActor::VisibilityChangedSignalType *) &Dali::DevelActor::VisibilityChangedSignal(arg1);
32546     } catch (std::out_of_range& e) {
32547       {
32548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32549       };
32550     } catch (std::exception& e) {
32551       {
32552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32553       };
32554     } catch (Dali::DaliException e) {
32555       {
32556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32557       };
32558     } catch (...) {
32559       {
32560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32561       };
32562     }
32563   }
32564
32565   jresult = (void *)result;
32566   return jresult;
32567 }
32568
32569
32570 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LayoutDirectionChangedSignal(void * jarg1) {
32571   void * jresult ;
32572   Dali::Actor *arg1 ;
32573   Dali::Actor::LayoutDirectionChangedSignalType *result = 0 ;
32574
32575   arg1 = (Dali::Actor *)jarg1;
32576   {
32577     try {
32578       result = (Dali::Actor::LayoutDirectionChangedSignalType *) &(arg1)->LayoutDirectionChangedSignal();
32579     } catch (std::out_of_range& e) {
32580       {
32581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
32582       };
32583     } catch (std::exception& e) {
32584       {
32585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
32586       };
32587     } catch (Dali::DaliException e) {
32588       {
32589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
32590       };
32591     } catch (...) {
32592       {
32593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
32594       };
32595     }
32596   }
32597
32598   jresult = (void *)result;
32599   return jresult;
32600 }
32601
32602
32603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_get() {
32604   int jresult ;
32605   int result;
32606
32607   result = (int)Dali::Actor::Property::PARENT_ORIGIN;
32608   jresult = (int)result;
32609   return jresult;
32610 }
32611
32612
32613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_X_get() {
32614   int jresult ;
32615   int result;
32616
32617   result = (int)Dali::Actor::Property::PARENT_ORIGIN_X;
32618   jresult = (int)result;
32619   return jresult;
32620 }
32621
32622
32623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Y_get() {
32624   int jresult ;
32625   int result;
32626
32627   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Y;
32628   jresult = (int)result;
32629   return jresult;
32630 }
32631
32632
32633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PARENT_ORIGIN_Z_get() {
32634   int jresult ;
32635   int result;
32636
32637   result = (int)Dali::Actor::Property::PARENT_ORIGIN_Z;
32638   jresult = (int)result;
32639   return jresult;
32640 }
32641
32642
32643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_get() {
32644   int jresult ;
32645   int result;
32646
32647   result = (int)Dali::Actor::Property::ANCHOR_POINT;
32648   jresult = (int)result;
32649   return jresult;
32650 }
32651
32652
32653 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_X_get() {
32654   int jresult ;
32655   int result;
32656
32657   result = (int)Dali::Actor::Property::ANCHOR_POINT_X;
32658   jresult = (int)result;
32659   return jresult;
32660 }
32661
32662
32663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Y_get() {
32664   int jresult ;
32665   int result;
32666
32667   result = (int)Dali::Actor::Property::ANCHOR_POINT_Y;
32668   jresult = (int)result;
32669   return jresult;
32670 }
32671
32672
32673 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ANCHOR_POINT_Z_get() {
32674   int jresult ;
32675   int result;
32676
32677   result = (int)Dali::Actor::Property::ANCHOR_POINT_Z;
32678   jresult = (int)result;
32679   return jresult;
32680 }
32681
32682
32683 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_get() {
32684   int jresult ;
32685   int result;
32686
32687   result = (int)Dali::Actor::Property::SIZE;
32688   jresult = (int)result;
32689   return jresult;
32690 }
32691
32692
32693 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_WIDTH_get() {
32694   int jresult ;
32695   int result;
32696
32697   result = (int)Dali::Actor::Property::SIZE_WIDTH;
32698   jresult = (int)result;
32699   return jresult;
32700 }
32701
32702
32703 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_HEIGHT_get() {
32704   int jresult ;
32705   int result;
32706
32707   result = (int)Dali::Actor::Property::SIZE_HEIGHT;
32708   jresult = (int)result;
32709   return jresult;
32710 }
32711
32712
32713 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_DEPTH_get() {
32714   int jresult ;
32715   int result;
32716
32717   result = (int)Dali::Actor::Property::SIZE_DEPTH;
32718   jresult = (int)result;
32719   return jresult;
32720 }
32721
32722
32723 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_get() {
32724   int jresult ;
32725   int result;
32726
32727   result = (int)Dali::Actor::Property::POSITION;
32728   jresult = (int)result;
32729   return jresult;
32730 }
32731
32732
32733 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_X_get() {
32734   int jresult ;
32735   int result;
32736
32737   result = (int)Dali::Actor::Property::POSITION_X;
32738   jresult = (int)result;
32739   return jresult;
32740 }
32741
32742
32743 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Y_get() {
32744   int jresult ;
32745   int result;
32746
32747   result = (int)Dali::Actor::Property::POSITION_Y;
32748   jresult = (int)result;
32749   return jresult;
32750 }
32751
32752
32753 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_POSITION_Z_get() {
32754   int jresult ;
32755   int result;
32756
32757   result = (int)Dali::Actor::Property::POSITION_Z;
32758   jresult = (int)result;
32759   return jresult;
32760 }
32761
32762
32763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_get() {
32764   int jresult ;
32765   int result;
32766
32767   result = (int)Dali::Actor::Property::WORLD_POSITION;
32768   jresult = (int)result;
32769   return jresult;
32770 }
32771
32772
32773 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_X_get() {
32774   int jresult ;
32775   int result;
32776
32777   result = (int)Dali::Actor::Property::WORLD_POSITION_X;
32778   jresult = (int)result;
32779   return jresult;
32780 }
32781
32782
32783 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Y_get() {
32784   int jresult ;
32785   int result;
32786
32787   result = (int)Dali::Actor::Property::WORLD_POSITION_Y;
32788   jresult = (int)result;
32789   return jresult;
32790 }
32791
32792
32793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_POSITION_Z_get() {
32794   int jresult ;
32795   int result;
32796
32797   result = (int)Dali::Actor::Property::WORLD_POSITION_Z;
32798   jresult = (int)result;
32799   return jresult;
32800 }
32801
32802
32803 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_ORIENTATION_get() {
32804   int jresult ;
32805   int result;
32806
32807   result = (int)Dali::Actor::Property::ORIENTATION;
32808   jresult = (int)result;
32809   return jresult;
32810 }
32811
32812
32813 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_ORIENTATION_get() {
32814   int jresult ;
32815   int result;
32816
32817   result = (int)Dali::Actor::Property::WORLD_ORIENTATION;
32818   jresult = (int)result;
32819   return jresult;
32820 }
32821
32822
32823 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_get() {
32824   int jresult ;
32825   int result;
32826
32827   result = (int)Dali::Actor::Property::SCALE;
32828   jresult = (int)result;
32829   return jresult;
32830 }
32831
32832
32833 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_X_get() {
32834   int jresult ;
32835   int result;
32836
32837   result = (int)Dali::Actor::Property::SCALE_X;
32838   jresult = (int)result;
32839   return jresult;
32840 }
32841
32842
32843 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Y_get() {
32844   int jresult ;
32845   int result;
32846
32847   result = (int)Dali::Actor::Property::SCALE_Y;
32848   jresult = (int)result;
32849   return jresult;
32850 }
32851
32852
32853 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SCALE_Z_get() {
32854   int jresult ;
32855   int result;
32856
32857   result = (int)Dali::Actor::Property::SCALE_Z;
32858   jresult = (int)result;
32859   return jresult;
32860 }
32861
32862
32863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_SCALE_get() {
32864   int jresult ;
32865   int result;
32866
32867   result = (int)Dali::Actor::Property::WORLD_SCALE;
32868   jresult = (int)result;
32869   return jresult;
32870 }
32871
32872
32873 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_VISIBLE_get() {
32874   int jresult ;
32875   int result;
32876
32877   result = (int)Dali::Actor::Property::VISIBLE;
32878   jresult = (int)result;
32879   return jresult;
32880 }
32881
32882
32883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_get() {
32884   int jresult ;
32885   int result;
32886
32887   result = (int)Dali::Actor::Property::COLOR;
32888   jresult = (int)result;
32889   return jresult;
32890 }
32891
32892
32893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_RED_get() {
32894   int jresult ;
32895   int result;
32896
32897   result = (int)Dali::Actor::Property::COLOR_RED;
32898   jresult = (int)result;
32899   return jresult;
32900 }
32901
32902
32903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_GREEN_get() {
32904   int jresult ;
32905   int result;
32906
32907   result = (int)Dali::Actor::Property::COLOR_GREEN;
32908   jresult = (int)result;
32909   return jresult;
32910 }
32911
32912
32913 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_BLUE_get() {
32914   int jresult ;
32915   int result;
32916
32917   result = (int)Dali::Actor::Property::COLOR_BLUE;
32918   jresult = (int)result;
32919   return jresult;
32920 }
32921
32922
32923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_ALPHA_get() {
32924   int jresult ;
32925   int result;
32926
32927   result = (int)Dali::Actor::Property::COLOR_ALPHA;
32928   jresult = (int)result;
32929   return jresult;
32930 }
32931
32932
32933 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_COLOR_get() {
32934   int jresult ;
32935   int result;
32936
32937   result = (int)Dali::Actor::Property::WORLD_COLOR;
32938   jresult = (int)result;
32939   return jresult;
32940 }
32941
32942
32943 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WORLD_MATRIX_get() {
32944   int jresult ;
32945   int result;
32946
32947   result = (int)Dali::Actor::Property::WORLD_MATRIX;
32948   jresult = (int)result;
32949   return jresult;
32950 }
32951
32952
32953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_NAME_get() {
32954   int jresult ;
32955   int result;
32956
32957   result = (int)Dali::Actor::Property::NAME;
32958   jresult = (int)result;
32959   return jresult;
32960 }
32961
32962
32963 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SENSITIVE_get() {
32964   int jresult ;
32965   int result;
32966
32967   result = (int)Dali::Actor::Property::SENSITIVE;
32968   jresult = (int)result;
32969   return jresult;
32970 }
32971
32972
32973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_LEAVE_REQUIRED_get() {
32974   int jresult ;
32975   int result;
32976
32977   result = (int)Dali::Actor::Property::LEAVE_REQUIRED;
32978   jresult = (int)result;
32979   return jresult;
32980 }
32981
32982
32983 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_ORIENTATION_get() {
32984   int jresult ;
32985   int result;
32986
32987   result = (int)Dali::Actor::Property::INHERIT_ORIENTATION;
32988   jresult = (int)result;
32989   return jresult;
32990 }
32991
32992
32993 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_SCALE_get() {
32994   int jresult ;
32995   int result;
32996
32997   result = (int)Dali::Actor::Property::INHERIT_SCALE;
32998   jresult = (int)result;
32999   return jresult;
33000 }
33001
33002
33003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_COLOR_MODE_get() {
33004   int jresult ;
33005   int result;
33006
33007   result = (int)Dali::Actor::Property::COLOR_MODE;
33008   jresult = (int)result;
33009   return jresult;
33010 }
33011
33012
33013 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_DRAW_MODE_get() {
33014   int jresult ;
33015   int result;
33016
33017   result = (int)Dali::Actor::Property::DRAW_MODE;
33018   jresult = (int)result;
33019   return jresult;
33020 }
33021
33022
33023 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_MODE_FACTOR_get() {
33024   int jresult ;
33025   int result;
33026
33027   result = (int)Dali::Actor::Property::SIZE_MODE_FACTOR;
33028   jresult = (int)result;
33029   return jresult;
33030 }
33031
33032
33033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_RESIZE_POLICY_get() {
33034   int jresult ;
33035   int result;
33036
33037   result = (int)Dali::Actor::Property::WIDTH_RESIZE_POLICY;
33038   jresult = (int)result;
33039   return jresult;
33040 }
33041
33042
33043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_RESIZE_POLICY_get() {
33044   int jresult ;
33045   int result;
33046
33047   result = (int)Dali::Actor::Property::HEIGHT_RESIZE_POLICY;
33048   jresult = (int)result;
33049   return jresult;
33050 }
33051
33052
33053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_SIZE_SCALE_POLICY_get() {
33054   int jresult ;
33055   int result;
33056
33057   result = (int)Dali::Actor::Property::SIZE_SCALE_POLICY;
33058   jresult = (int)result;
33059   return jresult;
33060 }
33061
33062
33063 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_WIDTH_FOR_HEIGHT_get() {
33064   int jresult ;
33065   int result;
33066
33067   result = (int)Dali::Actor::Property::WIDTH_FOR_HEIGHT;
33068   jresult = (int)result;
33069   return jresult;
33070 }
33071
33072
33073 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_HEIGHT_FOR_WIDTH_get() {
33074   int jresult ;
33075   int result;
33076
33077   result = (int)Dali::Actor::Property::HEIGHT_FOR_WIDTH;
33078   jresult = (int)result;
33079   return jresult;
33080 }
33081
33082
33083 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_PADDING_get() {
33084   int jresult ;
33085   int result;
33086
33087   result = (int)Dali::Actor::Property::PADDING;
33088   jresult = (int)result;
33089   return jresult;
33090 }
33091
33092
33093 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MINIMUM_SIZE_get() {
33094   int jresult ;
33095   int result;
33096
33097   result = (int)Dali::Actor::Property::MINIMUM_SIZE;
33098   jresult = (int)result;
33099   return jresult;
33100 }
33101
33102
33103 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_MAXIMUM_SIZE_get() {
33104   int jresult ;
33105   int result;
33106
33107   result = (int)Dali::Actor::Property::MAXIMUM_SIZE;
33108   jresult = (int)result;
33109   return jresult;
33110 }
33111
33112
33113 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_INHERIT_POSITION_get() {
33114   int jresult ;
33115   int result;
33116
33117   result = (int)Dali::Actor::Property::INHERIT_POSITION;
33118   jresult = (int)result;
33119   return jresult;
33120 }
33121
33122
33123 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_Property_CLIPPING_MODE_get() {
33124   int jresult ;
33125   int result;
33126
33127   result = (int)Dali::Actor::Property::CLIPPING_MODE;
33128   jresult = (int)result;
33129   return jresult;
33130 }
33131
33132 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_OPACITY_get() {
33133
33134   return Dali::Actor::Property::OPACITY;
33135 }
33136
33137 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_SCREEN_POSITION_get() {
33138
33139   return Dali::Actor::Property::SCREEN_POSITION;
33140 }
33141
33142 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_POSITION_USES_ANCHOR_POINT_get() {
33143
33144   return Dali::Actor::Property::POSITION_USES_ANCHOR_POINT;
33145 }
33146
33147 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_INHERIT_LAYOUT_DIRECTION_get() {
33148   return Dali::Actor::Property::INHERIT_LAYOUT_DIRECTION;
33149 }
33150
33151 SWIGEXPORT int SWIGSTDCALL CSharp_Actor_Property_LAYOUT_DIRECTION_get() {
33152   return Dali::Actor::Property::LAYOUT_DIRECTION;
33153 }
33154
33155 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor_Property() {
33156   void * jresult ;
33157   Dali::Actor::Property *result = 0 ;
33158
33159   {
33160     try {
33161       result = (Dali::Actor::Property *)new Dali::Actor::Property();
33162     } catch (std::out_of_range& e) {
33163       {
33164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33165       };
33166     } catch (std::exception& e) {
33167       {
33168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33169       };
33170     } catch (Dali::DaliException e) {
33171       {
33172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33173       };
33174     } catch (...) {
33175       {
33176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33177       };
33178     }
33179   }
33180
33181   jresult = (void *)result;
33182   return jresult;
33183 }
33184
33185
33186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor_Property(void * jarg1) {
33187   Dali::Actor::Property *arg1 = (Dali::Actor::Property *) 0 ;
33188
33189   arg1 = (Dali::Actor::Property *)jarg1;
33190   {
33191     try {
33192       delete arg1;
33193     } catch (std::out_of_range& e) {
33194       {
33195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33196       };
33197     } catch (std::exception& e) {
33198       {
33199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33200       };
33201     } catch (Dali::DaliException e) {
33202       {
33203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33204       };
33205     } catch (...) {
33206       {
33207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33208       };
33209     }
33210   }
33211
33212 }
33213
33214
33215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_0() {
33216   void * jresult ;
33217   Dali::Actor *result = 0 ;
33218
33219   {
33220     try {
33221       result = (Dali::Actor *)new Dali::Actor();
33222     } catch (std::out_of_range& e) {
33223       {
33224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33225       };
33226     } catch (std::exception& e) {
33227       {
33228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33229       };
33230     } catch (Dali::DaliException e) {
33231       {
33232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33233       };
33234     } catch (...) {
33235       {
33236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33237       };
33238     }
33239   }
33240
33241   jresult = (void *)result;
33242   return jresult;
33243 }
33244
33245
33246 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_New() {
33247   void * jresult ;
33248   Dali::Actor result;
33249
33250   {
33251     try {
33252       result = Dali::Actor::New();
33253     } catch (std::out_of_range& e) {
33254       {
33255         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33256       };
33257     } catch (std::exception& e) {
33258       {
33259         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33260       };
33261     } catch (Dali::DaliException e) {
33262       {
33263         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33264       };
33265     } catch (...) {
33266       {
33267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33268       };
33269     }
33270   }
33271
33272   jresult = new Dali::Actor((const Dali::Actor &)result);
33273   return jresult;
33274 }
33275
33276
33277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_DownCast(void * jarg1) {
33278   void * jresult ;
33279   Dali::BaseHandle arg1 ;
33280   Dali::BaseHandle *argp1 ;
33281   Dali::Actor result;
33282
33283   argp1 = (Dali::BaseHandle *)jarg1;
33284   if (!argp1) {
33285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
33286     return 0;
33287   }
33288   arg1 = *argp1;
33289   {
33290     try {
33291       result = Dali::Actor::DownCast(arg1);
33292     } catch (std::out_of_range& e) {
33293       {
33294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33295       };
33296     } catch (std::exception& e) {
33297       {
33298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33299       };
33300     } catch (Dali::DaliException e) {
33301       {
33302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33303       };
33304     } catch (...) {
33305       {
33306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33307       };
33308     }
33309   }
33310
33311   jresult = new Dali::Actor((const Dali::Actor &)result);
33312   return jresult;
33313 }
33314
33315
33316 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Actor(void * jarg1) {
33317   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33318
33319   arg1 = (Dali::Actor *)jarg1;
33320   {
33321     try {
33322       delete arg1;
33323     } catch (std::out_of_range& e) {
33324       {
33325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33326       };
33327     } catch (std::exception& e) {
33328       {
33329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33330       };
33331     } catch (Dali::DaliException e) {
33332       {
33333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33334       };
33335     } catch (...) {
33336       {
33337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33338       };
33339     }
33340   }
33341
33342 }
33343
33344
33345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Actor__SWIG_1(void * jarg1) {
33346   void * jresult ;
33347   Dali::Actor *arg1 = 0 ;
33348   Dali::Actor *result = 0 ;
33349
33350   arg1 = (Dali::Actor *)jarg1;
33351   if (!arg1) {
33352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33353     return 0;
33354   }
33355   {
33356     try {
33357       result = (Dali::Actor *)new Dali::Actor((Dali::Actor const &)*arg1);
33358     } catch (std::out_of_range& e) {
33359       {
33360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33361       };
33362     } catch (std::exception& e) {
33363       {
33364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33365       };
33366     } catch (Dali::DaliException e) {
33367       {
33368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33369       };
33370     } catch (...) {
33371       {
33372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33373       };
33374     }
33375   }
33376
33377   jresult = (void *)result;
33378   return jresult;
33379 }
33380
33381
33382 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_Assign(void * jarg1, void * jarg2) {
33383   void * jresult ;
33384   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33385   Dali::Actor *arg2 = 0 ;
33386   Dali::Actor *result = 0 ;
33387
33388   arg1 = (Dali::Actor *)jarg1;
33389   arg2 = (Dali::Actor *)jarg2;
33390   if (!arg2) {
33391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
33392     return 0;
33393   }
33394   {
33395     try {
33396       result = (Dali::Actor *) &(arg1)->operator =((Dali::Actor const &)*arg2);
33397     } catch (std::out_of_range& e) {
33398       {
33399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33400       };
33401     } catch (std::exception& e) {
33402       {
33403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33404       };
33405     } catch (Dali::DaliException e) {
33406       {
33407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33408       };
33409     } catch (...) {
33410       {
33411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33412       };
33413     }
33414   }
33415
33416   jresult = (void *)result;
33417   return jresult;
33418 }
33419
33420
33421 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_Actor_GetName(void * jarg1) {
33422   char * jresult ;
33423   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33424   std::string *result = 0 ;
33425
33426   arg1 = (Dali::Actor *)jarg1;
33427   {
33428     try {
33429       std::string name = ((Dali::Actor const *)arg1)->GetProperty< std::string >( Dali::Actor::Property::NAME );
33430       result = (std::string *) &name;
33431     } catch (std::out_of_range& e) {
33432       {
33433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33434       };
33435     } catch (std::exception& e) {
33436       {
33437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33438       };
33439     } catch (Dali::DaliException e) {
33440       {
33441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33442       };
33443     } catch (...) {
33444       {
33445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33446       };
33447     }
33448   }
33449
33450   jresult = SWIG_csharp_string_callback(result->c_str());
33451   return jresult;
33452 }
33453
33454
33455 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetName(void * jarg1, char * jarg2) {
33456   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33457   std::string *arg2 = 0 ;
33458
33459   arg1 = (Dali::Actor *)jarg1;
33460   if (!jarg2) {
33461     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33462     return ;
33463   }
33464   std::string arg2_str(jarg2);
33465   arg2 = &arg2_str;
33466   {
33467     try {
33468       (arg1)->SetProperty( Dali::Actor::Property::NAME, (std::string const &)*arg2);
33469     } catch (std::out_of_range& e) {
33470       {
33471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33472       };
33473     } catch (std::exception& e) {
33474       {
33475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33476       };
33477     } catch (Dali::DaliException e) {
33478       {
33479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33480       };
33481     } catch (...) {
33482       {
33483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33484       };
33485     }
33486   }
33487
33488
33489   //argout typemap for const std::string&
33490
33491 }
33492
33493
33494 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetId(void * jarg1) {
33495   unsigned int jresult ;
33496   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33497   unsigned int result;
33498
33499   arg1 = (Dali::Actor *)jarg1;
33500
33501   if(!arg1) {
33502     DALI_LOG_ERROR("[ERROR] actor is null! return -1");
33503     return -1;
33504   }
33505
33506   {
33507     try {
33508       result = (unsigned int)((Dali::Actor const *)arg1)->GetProperty< int >( Actor::Property::ID );
33509     } catch (std::out_of_range& e) {
33510       {
33511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33512       };
33513     } catch (std::exception& e) {
33514       {
33515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33516       };
33517     } catch (Dali::DaliException e) {
33518       {
33519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33520       };
33521     } catch (...) {
33522       {
33523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33524       };
33525     }
33526   }
33527
33528   jresult = result;
33529   return jresult;
33530 }
33531
33532
33533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsRoot(void * jarg1) {
33534   unsigned int jresult ;
33535   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33536   bool result;
33537
33538   arg1 = (Dali::Actor *)jarg1;
33539   {
33540     try {
33541       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_ROOT );
33542     } catch (std::out_of_range& e) {
33543       {
33544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33545       };
33546     } catch (std::exception& e) {
33547       {
33548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33549       };
33550     } catch (Dali::DaliException e) {
33551       {
33552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33553       };
33554     } catch (...) {
33555       {
33556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33557       };
33558     }
33559   }
33560
33561   jresult = result;
33562   return jresult;
33563 }
33564
33565
33566 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_OnStage(void * jarg1) {
33567   unsigned int jresult ;
33568   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33569   bool result;
33570
33571   arg1 = (Dali::Actor *)jarg1;
33572   {
33573     try {
33574       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::CONNECTED_TO_SCENE );
33575     } catch (std::out_of_range& e) {
33576       {
33577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33578       };
33579     } catch (std::exception& e) {
33580       {
33581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33582       };
33583     } catch (Dali::DaliException e) {
33584       {
33585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33586       };
33587     } catch (...) {
33588       {
33589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33590       };
33591     }
33592   }
33593
33594   jresult = result;
33595   return jresult;
33596 }
33597
33598
33599 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsLayer(void * jarg1) {
33600   unsigned int jresult ;
33601   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33602   bool result;
33603
33604   arg1 = (Dali::Actor *)jarg1;
33605   {
33606     try {
33607       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::IS_LAYER );
33608     } catch (std::out_of_range& e) {
33609       {
33610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33611       };
33612     } catch (std::exception& e) {
33613       {
33614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33615       };
33616     } catch (Dali::DaliException e) {
33617       {
33618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33619       };
33620     } catch (...) {
33621       {
33622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33623       };
33624     }
33625   }
33626
33627   jresult = result;
33628   return jresult;
33629 }
33630
33631
33632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetLayer(void * jarg1) {
33633   void * jresult ;
33634   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33635   Dali::Layer result;
33636
33637   arg1 = (Dali::Actor *)jarg1;
33638   {
33639     try {
33640       result = (arg1)->GetLayer();
33641     } catch (std::out_of_range& e) {
33642       {
33643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33644       };
33645     } catch (std::exception& e) {
33646       {
33647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33648       };
33649     } catch (Dali::DaliException e) {
33650       {
33651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33652       };
33653     } catch (...) {
33654       {
33655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33656       };
33657     }
33658   }
33659
33660   jresult = new Dali::Layer((const Dali::Layer &)result);
33661   return jresult;
33662 }
33663
33664
33665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Add(void * jarg1, void * jarg2) {
33666   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33667   Dali::Actor arg2 ;
33668   Dali::Actor *argp2 ;
33669
33670   arg1 = (Dali::Actor *)jarg1;
33671   argp2 = (Dali::Actor *)jarg2;
33672   if (!argp2) {
33673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33674     return ;
33675   }
33676   arg2 = *argp2;
33677   {
33678     try {
33679       (arg1)->Add(arg2);
33680     } catch (std::out_of_range& e) {
33681       {
33682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33683       };
33684     } catch (std::exception& e) {
33685       {
33686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33687       };
33688     } catch (Dali::DaliException e) {
33689       {
33690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33691       };
33692     } catch (...) {
33693       {
33694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33695       };
33696     }
33697   }
33698
33699 }
33700
33701
33702 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Remove(void * jarg1, void * jarg2) {
33703   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33704   Dali::Actor arg2 ;
33705   Dali::Actor *argp2 ;
33706
33707   arg1 = (Dali::Actor *)jarg1;
33708   argp2 = (Dali::Actor *)jarg2;
33709   if (!argp2) {
33710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
33711     return ;
33712   }
33713   arg2 = *argp2;
33714   {
33715     try {
33716       (arg1)->Remove(arg2);
33717     } catch (std::out_of_range& e) {
33718       {
33719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33720       };
33721     } catch (std::exception& e) {
33722       {
33723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33724       };
33725     } catch (Dali::DaliException e) {
33726       {
33727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33728       };
33729     } catch (...) {
33730       {
33731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33732       };
33733     }
33734   }
33735
33736 }
33737
33738
33739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_Unparent(void * jarg1) {
33740   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33741
33742   arg1 = (Dali::Actor *)jarg1;
33743   {
33744     try {
33745       (arg1)->Unparent();
33746     } catch (std::out_of_range& e) {
33747       {
33748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33749       };
33750     } catch (std::exception& e) {
33751       {
33752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33753       };
33754     } catch (Dali::DaliException e) {
33755       {
33756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33757       };
33758     } catch (...) {
33759       {
33760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33761       };
33762     }
33763   }
33764
33765 }
33766
33767
33768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetChildCount(void * jarg1) {
33769   unsigned int jresult ;
33770   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33771   unsigned int result;
33772
33773   arg1 = (Dali::Actor *)jarg1;
33774   {
33775     try {
33776       result = (unsigned int)((Dali::Actor const *)arg1)->GetChildCount();
33777     } catch (std::out_of_range& e) {
33778       {
33779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33780       };
33781     } catch (std::exception& e) {
33782       {
33783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33784       };
33785     } catch (Dali::DaliException e) {
33786       {
33787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33788       };
33789     } catch (...) {
33790       {
33791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33792       };
33793     }
33794   }
33795
33796   jresult = result;
33797   return jresult;
33798 }
33799
33800
33801 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetChildAt(void * jarg1, unsigned int jarg2) {
33802   void * jresult ;
33803   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33804   unsigned int arg2 ;
33805   Dali::Actor result;
33806
33807   arg1 = (Dali::Actor *)jarg1;
33808   arg2 = (unsigned int)jarg2;
33809   {
33810     try {
33811       result = ((Dali::Actor const *)arg1)->GetChildAt(arg2);
33812     } catch (std::out_of_range& e) {
33813       {
33814         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33815       };
33816     } catch (std::exception& e) {
33817       {
33818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33819       };
33820     } catch (Dali::DaliException e) {
33821       {
33822         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33823       };
33824     } catch (...) {
33825       {
33826         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33827       };
33828     }
33829   }
33830
33831   jresult = new Dali::Actor((const Dali::Actor &)result);
33832   return jresult;
33833 }
33834
33835
33836 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildByName(void * jarg1, char * jarg2) {
33837   void * jresult ;
33838   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33839   std::string *arg2 = 0 ;
33840   Dali::Actor result;
33841
33842   arg1 = (Dali::Actor *)jarg1;
33843   if (!jarg2) {
33844     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
33845     return 0;
33846   }
33847   std::string arg2_str(jarg2);
33848   arg2 = &arg2_str;
33849   {
33850     try {
33851       result = (arg1)->FindChildByName((std::string const &)*arg2);
33852     } catch (std::out_of_range& e) {
33853       {
33854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33855       };
33856     } catch (std::exception& e) {
33857       {
33858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33859       };
33860     } catch (Dali::DaliException e) {
33861       {
33862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33863       };
33864     } catch (...) {
33865       {
33866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33867       };
33868     }
33869   }
33870
33871   jresult = new Dali::Actor((const Dali::Actor &)result);
33872
33873   //argout typemap for const std::string&
33874
33875   return jresult;
33876 }
33877
33878
33879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_FindChildById(void * jarg1, unsigned int jarg2) {
33880   void * jresult ;
33881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33882   unsigned int arg2 ;
33883   Dali::Actor result;
33884
33885   arg1 = (Dali::Actor *)jarg1;
33886   arg2 = (unsigned int)jarg2;
33887   {
33888     try {
33889       result = (arg1)->FindChildById(arg2);
33890     } catch (std::out_of_range& e) {
33891       {
33892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33893       };
33894     } catch (std::exception& e) {
33895       {
33896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33897       };
33898     } catch (Dali::DaliException e) {
33899       {
33900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33901       };
33902     } catch (...) {
33903       {
33904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33905       };
33906     }
33907   }
33908
33909   jresult = new Dali::Actor((const Dali::Actor &)result);
33910   return jresult;
33911 }
33912
33913
33914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetParent(void * jarg1) {
33915   void * jresult ;
33916   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33917   Dali::Actor result;
33918
33919   arg1 = (Dali::Actor *)jarg1;
33920   {
33921     try {
33922       result = ((Dali::Actor const *)arg1)->GetParent();
33923     } catch (std::out_of_range& e) {
33924       {
33925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33926       };
33927     } catch (std::exception& e) {
33928       {
33929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33930       };
33931     } catch (Dali::DaliException e) {
33932       {
33933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
33934       };
33935     } catch (...) {
33936       {
33937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
33938       };
33939     }
33940   }
33941
33942   jresult = new Dali::Actor((const Dali::Actor &)result);
33943   return jresult;
33944 }
33945
33946
33947 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetParentOrigin(void * jarg1, void * jarg2) {
33948   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33949   Dali::Vector3 *arg2 = 0 ;
33950
33951   arg1 = (Dali::Actor *)jarg1;
33952   arg2 = (Dali::Vector3 *)jarg2;
33953   if (!arg2) {
33954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
33955     return ;
33956   }
33957   {
33958     try {
33959       (arg1)->SetProperty( Actor::Property::PARENT_ORIGIN,(Dali::Vector3 const &)*arg2);
33960     } catch (std::out_of_range& e) {
33961       {
33962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
33963       };
33964     } catch (std::exception& e) {
33965       {
33966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
33967       };
33968     } catch (Dali::DaliException e) {
33969       {
33970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
33971       };
33972     } catch (...) {
33973       {
33974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
33975       };
33976     }
33977   }
33978
33979 }
33980
33981
33982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentParentOrigin(void * jarg1) {
33983   void * jresult ;
33984   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
33985   Dali::Vector3 result;
33986
33987   arg1 = (Dali::Actor *)jarg1;
33988   {
33989     try {
33990       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::PARENT_ORIGIN );
33991     } catch (std::out_of_range& e) {
33992       {
33993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
33994       };
33995     } catch (std::exception& e) {
33996       {
33997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
33998       };
33999     } catch (Dali::DaliException e) {
34000       {
34001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34002       };
34003     } catch (...) {
34004       {
34005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34006       };
34007     }
34008   }
34009
34010   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34011   return jresult;
34012 }
34013
34014
34015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetAnchorPoint(void * jarg1, void * jarg2) {
34016   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34017   Dali::Vector3 *arg2 = 0 ;
34018
34019   arg1 = (Dali::Actor *)jarg1;
34020   arg2 = (Dali::Vector3 *)jarg2;
34021   if (!arg2) {
34022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34023     return ;
34024   }
34025   {
34026     try {
34027       (arg1)->SetProperty( Actor::Property::ANCHOR_POINT,(Dali::Vector3 const &)*arg2);
34028     } catch (std::out_of_range& e) {
34029       {
34030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34031       };
34032     } catch (std::exception& e) {
34033       {
34034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34035       };
34036     } catch (Dali::DaliException e) {
34037       {
34038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34039       };
34040     } catch (...) {
34041       {
34042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34043       };
34044     }
34045   }
34046
34047 }
34048
34049
34050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentAnchorPoint(void * jarg1) {
34051   void * jresult ;
34052   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34053   Dali::Vector3 result;
34054
34055   arg1 = (Dali::Actor *)jarg1;
34056   {
34057     try {
34058       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::ANCHOR_POINT );
34059     } catch (std::out_of_range& e) {
34060       {
34061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34062       };
34063     } catch (std::exception& e) {
34064       {
34065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34066       };
34067     } catch (Dali::DaliException e) {
34068       {
34069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34070       };
34071     } catch (...) {
34072       {
34073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34074       };
34075     }
34076   }
34077
34078   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34079   return jresult;
34080 }
34081
34082
34083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34084   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34085   float arg2 ;
34086   float arg3 ;
34087
34088   arg1 = (Dali::Actor *)jarg1;
34089   arg2 = (float)jarg2;
34090   arg3 = (float)jarg3;
34091   {
34092     try {
34093       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector2(arg2,arg3) );
34094     } catch (std::out_of_range& e) {
34095       {
34096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34097       };
34098     } catch (std::exception& e) {
34099       {
34100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34101       };
34102     } catch (Dali::DaliException e) {
34103       {
34104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34105       };
34106     } catch (...) {
34107       {
34108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34109       };
34110     }
34111   }
34112
34113 }
34114
34115
34116 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34117   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34118   float arg2 ;
34119   float arg3 ;
34120   float arg4 ;
34121
34122   arg1 = (Dali::Actor *)jarg1;
34123   arg2 = (float)jarg2;
34124   arg3 = (float)jarg3;
34125   arg4 = (float)jarg4;
34126   {
34127     try {
34128       (arg1)->SetProperty( Actor::Property::SIZE, Dali::Vector3(arg2,arg3,arg4) );
34129     } catch (std::out_of_range& e) {
34130       {
34131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34132       };
34133     } catch (std::exception& e) {
34134       {
34135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34136       };
34137     } catch (Dali::DaliException e) {
34138       {
34139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34140       };
34141     } catch (...) {
34142       {
34143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34144       };
34145     }
34146   }
34147
34148 }
34149
34150
34151 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_2(void * jarg1, void * jarg2) {
34152   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34153   Dali::Vector2 *arg2 = 0 ;
34154
34155   arg1 = (Dali::Actor *)jarg1;
34156   arg2 = (Dali::Vector2 *)jarg2;
34157   if (!arg2) {
34158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
34159     return ;
34160   }
34161   {
34162     try {
34163       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector2 const &)*arg2);
34164     } catch (std::out_of_range& e) {
34165       {
34166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34167       };
34168     } catch (std::exception& e) {
34169       {
34170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34171       };
34172     } catch (Dali::DaliException e) {
34173       {
34174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34175       };
34176     } catch (...) {
34177       {
34178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34179       };
34180     }
34181   }
34182
34183 }
34184
34185
34186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSize__SWIG_3(void * jarg1, void * jarg2) {
34187   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34188   Dali::Vector3 *arg2 = 0 ;
34189
34190   arg1 = (Dali::Actor *)jarg1;
34191   arg2 = (Dali::Vector3 *)jarg2;
34192   if (!arg2) {
34193     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34194     return ;
34195   }
34196   {
34197     try {
34198       (arg1)->SetProperty( Actor::Property::SIZE, (Dali::Vector3 const &)*arg2);
34199     } catch (std::out_of_range& e) {
34200       {
34201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34202       };
34203     } catch (std::exception& e) {
34204       {
34205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34206       };
34207     } catch (Dali::DaliException e) {
34208       {
34209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34210       };
34211     } catch (...) {
34212       {
34213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34214       };
34215     }
34216   }
34217
34218 }
34219
34220
34221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetTargetSize(void * jarg1) {
34222   void * jresult ;
34223   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34224   Dali::Vector3 result;
34225
34226   arg1 = (Dali::Actor *)jarg1;
34227   {
34228     try {
34229       result = ((Dali::Actor const *)arg1)->GetTargetSize();
34230     } catch (std::out_of_range& e) {
34231       {
34232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34233       };
34234     } catch (std::exception& e) {
34235       {
34236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34237       };
34238     } catch (Dali::DaliException e) {
34239       {
34240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34241       };
34242     } catch (...) {
34243       {
34244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34245       };
34246     }
34247   }
34248
34249   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34250   return jresult;
34251 }
34252
34253
34254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentSize(void * jarg1) {
34255   void * jresult ;
34256   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34257   Dali::Vector3 result;
34258
34259   arg1 = (Dali::Actor *)jarg1;
34260   {
34261     try {
34262       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SIZE );
34263     } catch (std::out_of_range& e) {
34264       {
34265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34266       };
34267     } catch (std::exception& e) {
34268       {
34269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34270       };
34271     } catch (Dali::DaliException e) {
34272       {
34273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34274       };
34275     } catch (...) {
34276       {
34277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34278       };
34279     }
34280   }
34281
34282   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34283   return jresult;
34284 }
34285
34286
34287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetNaturalSize(void * jarg1) {
34288   void * jresult ;
34289   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34290   Dali::Vector3 result;
34291
34292   arg1 = (Dali::Actor *)jarg1;
34293   {
34294     try {
34295       result = ((Dali::Actor const *)arg1)->GetNaturalSize();
34296     } catch (std::out_of_range& e) {
34297       {
34298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34299       };
34300     } catch (std::exception& e) {
34301       {
34302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34303       };
34304     } catch (Dali::DaliException e) {
34305       {
34306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34307       };
34308     } catch (...) {
34309       {
34310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34311       };
34312     }
34313   }
34314
34315   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34316   return jresult;
34317 }
34318
34319
34320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_0(void * jarg1, float jarg2, float jarg3) {
34321   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34322   float arg2 ;
34323   float arg3 ;
34324
34325   arg1 = (Dali::Actor *)jarg1;
34326   arg2 = (float)jarg2;
34327   arg3 = (float)jarg3;
34328   {
34329     try {
34330       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector2( arg2, arg3 ) );
34331     } catch (std::out_of_range& e) {
34332       {
34333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34334       };
34335     } catch (std::exception& e) {
34336       {
34337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34338       };
34339     } catch (Dali::DaliException e) {
34340       {
34341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34342       };
34343     } catch (...) {
34344       {
34345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34346       };
34347     }
34348   }
34349
34350 }
34351
34352
34353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
34354   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34355   float arg2 ;
34356   float arg3 ;
34357   float arg4 ;
34358
34359   arg1 = (Dali::Actor *)jarg1;
34360   arg2 = (float)jarg2;
34361   arg3 = (float)jarg3;
34362   arg4 = (float)jarg4;
34363   {
34364     try {
34365       (arg1)->SetProperty( Actor::Property::POSITION, Dali::Vector3( arg2, arg3, arg4 ) );
34366     } catch (std::out_of_range& e) {
34367       {
34368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34369       };
34370     } catch (std::exception& e) {
34371       {
34372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34373       };
34374     } catch (Dali::DaliException e) {
34375       {
34376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34377       };
34378     } catch (...) {
34379       {
34380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34381       };
34382     }
34383   }
34384
34385 }
34386
34387
34388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPosition__SWIG_2(void * jarg1, void * jarg2) {
34389   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34390   Dali::Vector3 *arg2 = 0 ;
34391
34392   arg1 = (Dali::Actor *)jarg1;
34393   arg2 = (Dali::Vector3 *)jarg2;
34394   if (!arg2) {
34395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34396     return ;
34397   }
34398   {
34399     try {
34400       (arg1)->SetProperty( Actor::Property::POSITION, (Dali::Vector3 const &)*arg2 );
34401     } catch (std::out_of_range& e) {
34402       {
34403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34404       };
34405     } catch (std::exception& e) {
34406       {
34407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34408       };
34409     } catch (Dali::DaliException e) {
34410       {
34411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34412       };
34413     } catch (...) {
34414       {
34415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34416       };
34417     }
34418   }
34419
34420 }
34421
34422
34423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetX(void * jarg1, float jarg2) {
34424   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34425   float arg2 ;
34426
34427   arg1 = (Dali::Actor *)jarg1;
34428   arg2 = (float)jarg2;
34429   {
34430     try {
34431       (arg1)->SetProperty( Actor::Property::POSITION_X, (arg2) );
34432     } catch (std::out_of_range& e) {
34433       {
34434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34435       };
34436     } catch (std::exception& e) {
34437       {
34438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34439       };
34440     } catch (Dali::DaliException e) {
34441       {
34442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34443       };
34444     } catch (...) {
34445       {
34446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34447       };
34448     }
34449   }
34450
34451 }
34452
34453
34454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetY(void * jarg1, float jarg2) {
34455   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34456   float arg2 ;
34457
34458   arg1 = (Dali::Actor *)jarg1;
34459   arg2 = (float)jarg2;
34460   {
34461     try {
34462       (arg1)->SetProperty( Actor::Property::POSITION_Y, arg2 );
34463     } catch (std::out_of_range& e) {
34464       {
34465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34466       };
34467     } catch (std::exception& e) {
34468       {
34469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34470       };
34471     } catch (Dali::DaliException e) {
34472       {
34473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34474       };
34475     } catch (...) {
34476       {
34477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34478       };
34479     }
34480   }
34481
34482 }
34483
34484
34485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetZ(void * jarg1, float jarg2) {
34486   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34487   float arg2 ;
34488
34489   arg1 = (Dali::Actor *)jarg1;
34490   arg2 = (float)jarg2;
34491   {
34492     try {
34493       (arg1)->SetProperty( Actor::Property::POSITION_Z, arg2 );
34494     } catch (std::out_of_range& e) {
34495       {
34496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34497       };
34498     } catch (std::exception& e) {
34499       {
34500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34501       };
34502     } catch (Dali::DaliException e) {
34503       {
34504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34505       };
34506     } catch (...) {
34507       {
34508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34509       };
34510     }
34511   }
34512
34513 }
34514
34515
34516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_TranslateBy(void * jarg1, void * jarg2) {
34517   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34518   Dali::Vector3 *arg2 = 0 ;
34519
34520   arg1 = (Dali::Actor *)jarg1;
34521   arg2 = (Dali::Vector3 *)jarg2;
34522   if (!arg2) {
34523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34524     return ;
34525   }
34526   {
34527     try {
34528       (arg1)->TranslateBy((Dali::Vector3 const &)*arg2);
34529     } catch (std::out_of_range& e) {
34530       {
34531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34532       };
34533     } catch (std::exception& e) {
34534       {
34535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34536       };
34537     } catch (Dali::DaliException e) {
34538       {
34539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34540       };
34541     } catch (...) {
34542       {
34543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34544       };
34545     }
34546   }
34547
34548 }
34549
34550
34551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentPosition(void * jarg1) {
34552   void * jresult ;
34553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34554   Dali::Vector3 result;
34555
34556   arg1 = (Dali::Actor *)jarg1;
34557   {
34558     try {
34559       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
34560     } catch (std::out_of_range& e) {
34561       {
34562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34563       };
34564     } catch (std::exception& e) {
34565       {
34566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34567       };
34568     } catch (Dali::DaliException e) {
34569       {
34570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34571       };
34572     } catch (...) {
34573       {
34574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34575       };
34576     }
34577   }
34578
34579   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34580   return jresult;
34581 }
34582
34583
34584 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldPosition(void * jarg1) {
34585   void * jresult ;
34586   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34587   Dali::Vector3 result;
34588
34589   arg1 = (Dali::Actor *)jarg1;
34590   {
34591     try {
34592       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
34593     } catch (std::out_of_range& e) {
34594       {
34595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34596       };
34597     } catch (std::exception& e) {
34598       {
34599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34600       };
34601     } catch (Dali::DaliException e) {
34602       {
34603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34604       };
34605     } catch (...) {
34606       {
34607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34608       };
34609     }
34610   }
34611
34612   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
34613   return jresult;
34614 }
34615
34616
34617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritPosition(void * jarg1, unsigned int jarg2) {
34618   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34619   bool arg2 ;
34620
34621   arg1 = (Dali::Actor *)jarg1;
34622   arg2 = jarg2 ? true : false;
34623   {
34624     try {
34625       (arg1)->SetProperty(Dali::Actor::Property::INHERIT_POSITION, arg2);
34626     } catch (std::out_of_range& e) {
34627       {
34628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34629       };
34630     } catch (std::exception& e) {
34631       {
34632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34633       };
34634     } catch (Dali::DaliException e) {
34635       {
34636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34637       };
34638     } catch (...) {
34639       {
34640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34641       };
34642     }
34643   }
34644
34645 }
34646
34647
34648 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsPositionInherited(void * jarg1) {
34649   unsigned int jresult ;
34650   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34651   bool result;
34652
34653   arg1 = (Dali::Actor *)jarg1;
34654   {
34655     try {
34656       result = (bool)((Dali::Actor const *)arg1)->GetProperty<bool>(Dali::Actor::Property::INHERIT_POSITION);
34657     } catch (std::out_of_range& e) {
34658       {
34659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34660       };
34661     } catch (std::exception& e) {
34662       {
34663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34664       };
34665     } catch (Dali::DaliException e) {
34666       {
34667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34668       };
34669     } catch (...) {
34670       {
34671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34672       };
34673     }
34674   }
34675
34676   jresult = result;
34677   return jresult;
34678 }
34679
34680
34681 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34682   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34683   Dali::Degree *arg2 = 0 ;
34684   Dali::Vector3 *arg3 = 0 ;
34685
34686   arg1 = (Dali::Actor *)jarg1;
34687   arg2 = (Dali::Degree *)jarg2;
34688   if (!arg2) {
34689     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34690     return ;
34691   }
34692   arg3 = (Dali::Vector3 *)jarg3;
34693   if (!arg3) {
34694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34695     return ;
34696   }
34697   {
34698     try {
34699       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34700     } catch (std::out_of_range& e) {
34701       {
34702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34703       };
34704     } catch (std::exception& e) {
34705       {
34706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34707       };
34708     } catch (Dali::DaliException e) {
34709       {
34710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34711       };
34712     } catch (...) {
34713       {
34714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34715       };
34716     }
34717   }
34718
34719 }
34720
34721
34722 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34723   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34724   Dali::Radian *arg2 = 0 ;
34725   Dali::Vector3 *arg3 = 0 ;
34726
34727   arg1 = (Dali::Actor *)jarg1;
34728   arg2 = (Dali::Radian *)jarg2;
34729   if (!arg2) {
34730     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34731     return ;
34732   }
34733   arg3 = (Dali::Vector3 *)jarg3;
34734   if (!arg3) {
34735     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34736     return ;
34737   }
34738   {
34739     try {
34740       (arg1)->SetProperty( Actor::Property::ORIENTATION, Quaternion( (Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3 ) );
34741     } catch (std::out_of_range& e) {
34742       {
34743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34744       };
34745     } catch (std::exception& e) {
34746       {
34747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34748       };
34749     } catch (Dali::DaliException e) {
34750       {
34751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34752       };
34753     } catch (...) {
34754       {
34755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34756       };
34757     }
34758   }
34759
34760 }
34761
34762
34763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOrientation__SWIG_2(void * jarg1, void * jarg2) {
34764   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34765   Dali::Quaternion *arg2 = 0 ;
34766
34767   arg1 = (Dali::Actor *)jarg1;
34768   arg2 = (Dali::Quaternion *)jarg2;
34769   if (!arg2) {
34770     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34771     return ;
34772   }
34773   {
34774     try {
34775       (arg1)->SetProperty( Actor::Property::ORIENTATION, (Dali::Quaternion const &)*arg2 );
34776     } catch (std::out_of_range& e) {
34777       {
34778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34779       };
34780     } catch (std::exception& e) {
34781       {
34782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34783       };
34784     } catch (Dali::DaliException e) {
34785       {
34786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34787       };
34788     } catch (...) {
34789       {
34790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34791       };
34792     }
34793   }
34794
34795 }
34796
34797
34798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
34799   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34800   Dali::Degree *arg2 = 0 ;
34801   Dali::Vector3 *arg3 = 0 ;
34802
34803   arg1 = (Dali::Actor *)jarg1;
34804   arg2 = (Dali::Degree *)jarg2;
34805   if (!arg2) {
34806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Degree const & type is null", 0);
34807     return ;
34808   }
34809   arg3 = (Dali::Vector3 *)jarg3;
34810   if (!arg3) {
34811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34812     return ;
34813   }
34814   {
34815     try {
34816       (arg1)->RotateBy((Dali::Degree const &)*arg2,(Dali::Vector3 const &)*arg3);
34817     } catch (std::out_of_range& e) {
34818       {
34819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34820       };
34821     } catch (std::exception& e) {
34822       {
34823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34824       };
34825     } catch (Dali::DaliException e) {
34826       {
34827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34828       };
34829     } catch (...) {
34830       {
34831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34832       };
34833     }
34834   }
34835
34836 }
34837
34838
34839 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
34840   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34841   Dali::Radian *arg2 = 0 ;
34842   Dali::Vector3 *arg3 = 0 ;
34843
34844   arg1 = (Dali::Actor *)jarg1;
34845   arg2 = (Dali::Radian *)jarg2;
34846   if (!arg2) {
34847     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Radian const & type is null", 0);
34848     return ;
34849   }
34850   arg3 = (Dali::Vector3 *)jarg3;
34851   if (!arg3) {
34852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
34853     return ;
34854   }
34855   {
34856     try {
34857       (arg1)->RotateBy((Dali::Radian const &)*arg2,(Dali::Vector3 const &)*arg3);
34858     } catch (std::out_of_range& e) {
34859       {
34860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34861       };
34862     } catch (std::exception& e) {
34863       {
34864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34865       };
34866     } catch (Dali::DaliException e) {
34867       {
34868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34869       };
34870     } catch (...) {
34871       {
34872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34873       };
34874     }
34875   }
34876
34877 }
34878
34879
34880 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RotateBy__SWIG_2(void * jarg1, void * jarg2) {
34881   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34882   Dali::Quaternion *arg2 = 0 ;
34883
34884   arg1 = (Dali::Actor *)jarg1;
34885   arg2 = (Dali::Quaternion *)jarg2;
34886   if (!arg2) {
34887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Quaternion const & type is null", 0);
34888     return ;
34889   }
34890   {
34891     try {
34892       (arg1)->RotateBy((Dali::Quaternion const &)*arg2);
34893     } catch (std::out_of_range& e) {
34894       {
34895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34896       };
34897     } catch (std::exception& e) {
34898       {
34899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34900       };
34901     } catch (Dali::DaliException e) {
34902       {
34903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34904       };
34905     } catch (...) {
34906       {
34907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34908       };
34909     }
34910   }
34911
34912 }
34913
34914
34915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOrientation(void * jarg1) {
34916   void * jresult ;
34917   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34918   Dali::Quaternion result;
34919
34920   arg1 = (Dali::Actor *)jarg1;
34921   {
34922     try {
34923       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::ORIENTATION );
34924     } catch (std::out_of_range& e) {
34925       {
34926         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34927       };
34928     } catch (std::exception& e) {
34929       {
34930         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34931       };
34932     } catch (Dali::DaliException e) {
34933       {
34934         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34935       };
34936     } catch (...) {
34937       {
34938         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
34939       };
34940     }
34941   }
34942
34943   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
34944   return jresult;
34945 }
34946
34947
34948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritOrientation(void * jarg1, unsigned int jarg2) {
34949   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34950   bool arg2 ;
34951
34952   arg1 = (Dali::Actor *)jarg1;
34953   arg2 = jarg2 ? true : false;
34954   {
34955     try {
34956       (arg1)->SetProperty( Actor::Property::INHERIT_ORIENTATION,arg2);
34957     } catch (std::out_of_range& e) {
34958       {
34959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
34960       };
34961     } catch (std::exception& e) {
34962       {
34963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
34964       };
34965     } catch (Dali::DaliException e) {
34966       {
34967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
34968       };
34969     } catch (...) {
34970       {
34971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
34972       };
34973     }
34974   }
34975
34976 }
34977
34978
34979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsOrientationInherited(void * jarg1) {
34980   unsigned int jresult ;
34981   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
34982   bool result;
34983
34984   arg1 = (Dali::Actor *)jarg1;
34985   {
34986     try {
34987       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_ORIENTATION );
34988     } catch (std::out_of_range& e) {
34989       {
34990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
34991       };
34992     } catch (std::exception& e) {
34993       {
34994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
34995       };
34996     } catch (Dali::DaliException e) {
34997       {
34998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
34999       };
35000     } catch (...) {
35001       {
35002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35003       };
35004     }
35005   }
35006
35007   jresult = result;
35008   return jresult;
35009 }
35010
35011
35012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldOrientation(void * jarg1) {
35013   void * jresult ;
35014   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35015   Dali::Quaternion result;
35016
35017   arg1 = (Dali::Actor *)jarg1;
35018   {
35019     try {
35020       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Quaternion >( Actor::Property::WORLD_ORIENTATION );
35021     } catch (std::out_of_range& e) {
35022       {
35023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35024       };
35025     } catch (std::exception& e) {
35026       {
35027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35028       };
35029     } catch (Dali::DaliException e) {
35030       {
35031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35032       };
35033     } catch (...) {
35034       {
35035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35036       };
35037     }
35038   }
35039
35040   jresult = new Dali::Quaternion((const Dali::Quaternion &)result);
35041   return jresult;
35042 }
35043
35044
35045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_0(void * jarg1, float jarg2) {
35046   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35047   float arg2 ;
35048
35049   arg1 = (Dali::Actor *)jarg1;
35050   arg2 = (float)jarg2;
35051   {
35052     try {
35053       (arg1)->SetProperty( Actor::Property::SCALE, arg2);
35054     } catch (std::out_of_range& e) {
35055       {
35056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35057       };
35058     } catch (std::exception& e) {
35059       {
35060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35061       };
35062     } catch (Dali::DaliException e) {
35063       {
35064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35065       };
35066     } catch (...) {
35067       {
35068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35069       };
35070     }
35071   }
35072
35073 }
35074
35075
35076 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
35077   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35078   float arg2 ;
35079   float arg3 ;
35080   float arg4 ;
35081
35082   arg1 = (Dali::Actor *)jarg1;
35083   arg2 = (float)jarg2;
35084   arg3 = (float)jarg3;
35085   arg4 = (float)jarg4;
35086   {
35087     try {
35088       (arg1)->SetProperty( Actor::Property::SCALE, Vector3( arg2, arg3, arg4 ) );
35089     } catch (std::out_of_range& e) {
35090       {
35091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35092       };
35093     } catch (std::exception& e) {
35094       {
35095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35096       };
35097     } catch (Dali::DaliException e) {
35098       {
35099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35100       };
35101     } catch (...) {
35102       {
35103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35104       };
35105     }
35106   }
35107
35108 }
35109
35110
35111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetScale__SWIG_2(void * jarg1, void * jarg2) {
35112   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35113   Dali::Vector3 *arg2 = 0 ;
35114
35115   arg1 = (Dali::Actor *)jarg1;
35116   arg2 = (Dali::Vector3 *)jarg2;
35117   if (!arg2) {
35118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35119     return ;
35120   }
35121   {
35122     try {
35123       (arg1)->SetProperty( Actor::Property::SCALE, (Dali::Vector3 const &)*arg2 );
35124     } catch (std::out_of_range& e) {
35125       {
35126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35127       };
35128     } catch (std::exception& e) {
35129       {
35130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35131       };
35132     } catch (Dali::DaliException e) {
35133       {
35134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35135       };
35136     } catch (...) {
35137       {
35138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35139       };
35140     }
35141   }
35142
35143 }
35144
35145
35146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_ScaleBy(void * jarg1, void * jarg2) {
35147   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35148   Dali::Vector3 *arg2 = 0 ;
35149
35150   arg1 = (Dali::Actor *)jarg1;
35151   arg2 = (Dali::Vector3 *)jarg2;
35152   if (!arg2) {
35153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
35154     return ;
35155   }
35156   {
35157     try {
35158       (arg1)->ScaleBy((Dali::Vector3 const &)*arg2);
35159     } catch (std::out_of_range& e) {
35160       {
35161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35162       };
35163     } catch (std::exception& e) {
35164       {
35165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35166       };
35167     } catch (Dali::DaliException e) {
35168       {
35169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35170       };
35171     } catch (...) {
35172       {
35173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35174       };
35175     }
35176   }
35177
35178 }
35179
35180
35181 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentScale(void * jarg1) {
35182   void * jresult ;
35183   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35184   Dali::Vector3 result;
35185
35186   arg1 = (Dali::Actor *)jarg1;
35187   {
35188     try {
35189       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::SCALE );
35190     } catch (std::out_of_range& e) {
35191       {
35192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35193       };
35194     } catch (std::exception& e) {
35195       {
35196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35197       };
35198     } catch (Dali::DaliException e) {
35199       {
35200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35201       };
35202     } catch (...) {
35203       {
35204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35205       };
35206     }
35207   }
35208
35209   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35210   return jresult;
35211 }
35212
35213
35214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldScale(void * jarg1) {
35215   void * jresult ;
35216   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35217   Dali::Vector3 result;
35218
35219   arg1 = (Dali::Actor *)jarg1;
35220   {
35221     try {
35222       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector3 >( Actor::Property::WORLD_SCALE );
35223     } catch (std::out_of_range& e) {
35224       {
35225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35226       };
35227     } catch (std::exception& e) {
35228       {
35229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35230       };
35231     } catch (Dali::DaliException e) {
35232       {
35233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35234       };
35235     } catch (...) {
35236       {
35237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35238       };
35239     }
35240   }
35241
35242   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
35243   return jresult;
35244 }
35245
35246
35247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetInheritScale(void * jarg1, unsigned int jarg2) {
35248   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35249   bool arg2 ;
35250
35251   arg1 = (Dali::Actor *)jarg1;
35252   arg2 = jarg2 ? true : false;
35253   {
35254     try {
35255       (arg1)->SetProperty( Actor::Property::INHERIT_SCALE,arg2);
35256     } catch (std::out_of_range& e) {
35257       {
35258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35259       };
35260     } catch (std::exception& e) {
35261       {
35262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35263       };
35264     } catch (Dali::DaliException e) {
35265       {
35266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35267       };
35268     } catch (...) {
35269       {
35270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35271       };
35272     }
35273   }
35274
35275 }
35276
35277
35278 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsScaleInherited(void * jarg1) {
35279   unsigned int jresult ;
35280   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35281   bool result;
35282
35283   arg1 = (Dali::Actor *)jarg1;
35284   {
35285     try {
35286       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::INHERIT_SCALE );
35287     } catch (std::out_of_range& e) {
35288       {
35289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35290       };
35291     } catch (std::exception& e) {
35292       {
35293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35294       };
35295     } catch (Dali::DaliException e) {
35296       {
35297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35298       };
35299     } catch (...) {
35300       {
35301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35302       };
35303     }
35304   }
35305
35306   jresult = result;
35307   return jresult;
35308 }
35309
35310
35311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldMatrix(void * jarg1) {
35312   void * jresult ;
35313   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35314   Dali::Matrix result;
35315
35316   arg1 = (Dali::Actor *)jarg1;
35317   {
35318     try {
35319       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Matrix >( Actor::Property::WORLD_MATRIX );
35320     } catch (std::out_of_range& e) {
35321       {
35322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35323       };
35324     } catch (std::exception& e) {
35325       {
35326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35327       };
35328     } catch (Dali::DaliException e) {
35329       {
35330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35331       };
35332     } catch (...) {
35333       {
35334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35335       };
35336     }
35337   }
35338
35339   jresult = new Dali::Matrix((const Dali::Matrix &)result);
35340   return jresult;
35341 }
35342
35343
35344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetVisible(void * jarg1, unsigned int jarg2) {
35345   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35346   bool arg2 ;
35347
35348   arg1 = (Dali::Actor *)jarg1;
35349   arg2 = jarg2 ? true : false;
35350   {
35351     try {
35352       (arg1)->SetProperty( Actor::Property::VISIBLE,arg2);
35353     } catch (std::out_of_range& e) {
35354       {
35355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35356       };
35357     } catch (std::exception& e) {
35358       {
35359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35360       };
35361     } catch (Dali::DaliException e) {
35362       {
35363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35364       };
35365     } catch (...) {
35366       {
35367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35368       };
35369     }
35370   }
35371
35372 }
35373
35374
35375 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsVisible(void * jarg1) {
35376   unsigned int jresult ;
35377   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35378   bool result;
35379
35380   arg1 = (Dali::Actor *)jarg1;
35381   {
35382     try {
35383       result = (bool)((Dali::Actor const *)arg1)->GetCurrentProperty< bool >( Actor::Property::VISIBLE );
35384     } catch (std::out_of_range& e) {
35385       {
35386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35387       };
35388     } catch (std::exception& e) {
35389       {
35390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35391       };
35392     } catch (Dali::DaliException e) {
35393       {
35394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35395       };
35396     } catch (...) {
35397       {
35398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35399       };
35400     }
35401   }
35402
35403   jresult = result;
35404   return jresult;
35405 }
35406
35407
35408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetOpacity(void * jarg1, float jarg2) {
35409   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35410   float arg2 ;
35411
35412   arg1 = (Dali::Actor *)jarg1;
35413   arg2 = (float)jarg2;
35414   {
35415     try {
35416       (arg1)->SetProperty( Actor::Property::OPACITY,arg2);
35417     } catch (std::out_of_range& e) {
35418       {
35419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35420       };
35421     } catch (std::exception& e) {
35422       {
35423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35424       };
35425     } catch (Dali::DaliException e) {
35426       {
35427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35428       };
35429     } catch (...) {
35430       {
35431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35432       };
35433     }
35434   }
35435
35436 }
35437
35438
35439 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetCurrentOpacity(void * jarg1) {
35440   float jresult ;
35441   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35442   float result;
35443
35444   arg1 = (Dali::Actor *)jarg1;
35445   {
35446     try {
35447       result = (float)((Dali::Actor const *)arg1)->GetCurrentProperty< float >( Actor::Property::OPACITY );
35448     } catch (std::out_of_range& e) {
35449       {
35450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35451       };
35452     } catch (std::exception& e) {
35453       {
35454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35455       };
35456     } catch (Dali::DaliException e) {
35457       {
35458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35459       };
35460     } catch (...) {
35461       {
35462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35463       };
35464     }
35465   }
35466
35467   jresult = result;
35468   return jresult;
35469 }
35470
35471
35472 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColor(void * jarg1, void * jarg2) {
35473   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35474   Dali::Vector4 *arg2 = 0 ;
35475
35476   arg1 = (Dali::Actor *)jarg1;
35477   arg2 = (Dali::Vector4 *)jarg2;
35478   if (!arg2) {
35479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
35480     return ;
35481   }
35482   {
35483     try {
35484       (arg1)->SetProperty( Actor::Property::COLOR,(Dali::Vector4 const &)*arg2);
35485     } catch (std::out_of_range& e) {
35486       {
35487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35488       };
35489     } catch (std::exception& e) {
35490       {
35491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35492       };
35493     } catch (Dali::DaliException e) {
35494       {
35495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35496       };
35497     } catch (...) {
35498       {
35499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35500       };
35501     }
35502   }
35503
35504 }
35505
35506
35507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentColor(void * jarg1) {
35508   void * jresult ;
35509   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35510   Dali::Vector4 result;
35511
35512   arg1 = (Dali::Actor *)jarg1;
35513   {
35514     try {
35515       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::COLOR );
35516     } catch (std::out_of_range& e) {
35517       {
35518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35519       };
35520     } catch (std::exception& e) {
35521       {
35522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35523       };
35524     } catch (Dali::DaliException e) {
35525       {
35526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35527       };
35528     } catch (...) {
35529       {
35530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35531       };
35532     }
35533   }
35534
35535   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35536   return jresult;
35537 }
35538
35539
35540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetColorMode(void * jarg1, int jarg2) {
35541   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35542   Dali::ColorMode arg2 ;
35543
35544   arg1 = (Dali::Actor *)jarg1;
35545   arg2 = (Dali::ColorMode)jarg2;
35546   {
35547     try {
35548       (arg1)->SetProperty( Actor::Property::COLOR_MODE,arg2);
35549     } catch (std::out_of_range& e) {
35550       {
35551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35552       };
35553     } catch (std::exception& e) {
35554       {
35555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35556       };
35557     } catch (Dali::DaliException e) {
35558       {
35559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35560       };
35561     } catch (...) {
35562       {
35563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35564       };
35565     }
35566   }
35567
35568 }
35569
35570
35571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetColorMode(void * jarg1) {
35572   int jresult ;
35573   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35574   Dali::ColorMode result;
35575
35576   arg1 = (Dali::Actor *)jarg1;
35577   {
35578     try {
35579       result = (Dali::ColorMode)((Dali::Actor const *)arg1)->GetProperty< ColorMode >( Actor::Property::COLOR_MODE );
35580     } catch (std::out_of_range& e) {
35581       {
35582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35583       };
35584     } catch (std::exception& e) {
35585       {
35586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35587       };
35588     } catch (Dali::DaliException e) {
35589       {
35590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35591       };
35592     } catch (...) {
35593       {
35594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35595       };
35596     }
35597   }
35598
35599   jresult = (int)result;
35600   return jresult;
35601 }
35602
35603
35604 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetCurrentWorldColor(void * jarg1) {
35605   void * jresult ;
35606   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35607   Dali::Vector4 result;
35608
35609   arg1 = (Dali::Actor *)jarg1;
35610   {
35611     try {
35612       result = ((Dali::Actor const *)arg1)->GetCurrentProperty< Vector4 >( Actor::Property::WORLD_COLOR );
35613     } catch (std::out_of_range& e) {
35614       {
35615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35616       };
35617     } catch (std::exception& e) {
35618       {
35619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35620       };
35621     } catch (Dali::DaliException e) {
35622       {
35623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35624       };
35625     } catch (...) {
35626       {
35627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35628       };
35629     }
35630   }
35631
35632   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
35633   return jresult;
35634 }
35635
35636
35637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetDrawMode(void * jarg1, int jarg2) {
35638   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35639   Dali::DrawMode::Type arg2 ;
35640
35641   arg1 = (Dali::Actor *)jarg1;
35642   arg2 = (Dali::DrawMode::Type)jarg2;
35643   {
35644     try {
35645       (arg1)->SetProperty( Actor::Property::DRAW_MODE,arg2);
35646     } catch (std::out_of_range& e) {
35647       {
35648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35649       };
35650     } catch (std::exception& e) {
35651       {
35652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35653       };
35654     } catch (Dali::DaliException e) {
35655       {
35656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35657       };
35658     } catch (...) {
35659       {
35660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35661       };
35662     }
35663   }
35664
35665 }
35666
35667
35668 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetDrawMode(void * jarg1) {
35669   int jresult ;
35670   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35671   Dali::DrawMode::Type result;
35672
35673   arg1 = (Dali::Actor *)jarg1;
35674   {
35675     try {
35676       result = (Dali::DrawMode::Type)((Dali::Actor const *)arg1)->GetProperty< DrawMode::Type >( Actor::Property::DRAW_MODE );
35677     } catch (std::out_of_range& e) {
35678       {
35679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35680       };
35681     } catch (std::exception& e) {
35682       {
35683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35684       };
35685     } catch (Dali::DaliException e) {
35686       {
35687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35688       };
35689     } catch (...) {
35690       {
35691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35692       };
35693     }
35694   }
35695
35696   jresult = (int)result;
35697   return jresult;
35698 }
35699
35700
35701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSensitive(void * jarg1, unsigned int jarg2) {
35702   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35703   bool arg2 ;
35704
35705   arg1 = (Dali::Actor *)jarg1;
35706   arg2 = jarg2 ? true : false;
35707   {
35708     try {
35709       (arg1)->SetProperty( Actor::Property::SENSITIVE,arg2);
35710     } catch (std::out_of_range& e) {
35711       {
35712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35713       };
35714     } catch (std::exception& e) {
35715       {
35716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35717       };
35718     } catch (Dali::DaliException e) {
35719       {
35720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35721       };
35722     } catch (...) {
35723       {
35724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35725       };
35726     }
35727   }
35728
35729 }
35730
35731
35732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsSensitive(void * jarg1) {
35733   unsigned int jresult ;
35734   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35735   bool result;
35736
35737   arg1 = (Dali::Actor *)jarg1;
35738   {
35739     try {
35740       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::SENSITIVE );
35741     } catch (std::out_of_range& e) {
35742       {
35743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35744       };
35745     } catch (std::exception& e) {
35746       {
35747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35748       };
35749     } catch (Dali::DaliException e) {
35750       {
35751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35752       };
35753     } catch (...) {
35754       {
35755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35756       };
35757     }
35758   }
35759
35760   jresult = result;
35761   return jresult;
35762 }
35763
35764
35765 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_ScreenToLocal(void * jarg1, float * jarg2, float * jarg3, float jarg4, float jarg5) {
35766   unsigned int jresult ;
35767   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35768   float *arg2 = 0 ;
35769   float *arg3 = 0 ;
35770   float arg4 ;
35771   float arg5 ;
35772   bool result;
35773
35774   arg1 = (Dali::Actor *)jarg1;
35775   arg2 = (float *)jarg2;
35776   arg3 = (float *)jarg3;
35777   arg4 = (float)jarg4;
35778   arg5 = (float)jarg5;
35779   {
35780     try {
35781       result = (bool)((Dali::Actor const *)arg1)->ScreenToLocal(*arg2,*arg3,arg4,arg5);
35782     } catch (std::out_of_range& e) {
35783       {
35784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35785       };
35786     } catch (std::exception& e) {
35787       {
35788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35789       };
35790     } catch (Dali::DaliException e) {
35791       {
35792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35793       };
35794     } catch (...) {
35795       {
35796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35797       };
35798     }
35799   }
35800
35801   jresult = result;
35802   return jresult;
35803 }
35804
35805
35806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetLeaveRequired(void * jarg1, unsigned int jarg2) {
35807   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35808   bool arg2 ;
35809
35810   arg1 = (Dali::Actor *)jarg1;
35811   arg2 = jarg2 ? true : false;
35812   {
35813     try {
35814       (arg1)->SetProperty( Actor::Property::LEAVE_REQUIRED,arg2);
35815     } catch (std::out_of_range& e) {
35816       {
35817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35818       };
35819     } catch (std::exception& e) {
35820       {
35821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35822       };
35823     } catch (Dali::DaliException e) {
35824       {
35825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35826       };
35827     } catch (...) {
35828       {
35829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35830       };
35831     }
35832   }
35833
35834 }
35835
35836
35837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetLeaveRequired(void * jarg1) {
35838   unsigned int jresult ;
35839   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35840   bool result;
35841
35842   arg1 = (Dali::Actor *)jarg1;
35843   {
35844     try {
35845       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::LEAVE_REQUIRED );
35846     } catch (std::out_of_range& e) {
35847       {
35848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35849       };
35850     } catch (std::exception& e) {
35851       {
35852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35853       };
35854     } catch (Dali::DaliException e) {
35855       {
35856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35857       };
35858     } catch (...) {
35859       {
35860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35861       };
35862     }
35863   }
35864
35865   jresult = result;
35866   return jresult;
35867 }
35868
35869
35870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetKeyboardFocusable(void * jarg1, unsigned int jarg2) {
35871   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35872   bool arg2 ;
35873
35874   arg1 = (Dali::Actor *)jarg1;
35875   arg2 = jarg2 ? true : false;
35876   {
35877     try {
35878       (arg1)->SetProperty( Actor::Property::KEYBOARD_FOCUSABLE, arg2 );
35879     } catch (std::out_of_range& e) {
35880       {
35881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35882       };
35883     } catch (std::exception& e) {
35884       {
35885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35886       };
35887     } catch (Dali::DaliException e) {
35888       {
35889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35890       };
35891     } catch (...) {
35892       {
35893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35894       };
35895     }
35896   }
35897
35898 }
35899
35900
35901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_IsKeyboardFocusable(void * jarg1) {
35902   unsigned int jresult ;
35903   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35904   bool result;
35905
35906   arg1 = (Dali::Actor *)jarg1;
35907   {
35908     try {
35909       result = (bool)((Dali::Actor const *)arg1)->GetProperty< bool >( Actor::Property::KEYBOARD_FOCUSABLE );
35910     } catch (std::out_of_range& e) {
35911       {
35912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35913       };
35914     } catch (std::exception& e) {
35915       {
35916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35917       };
35918     } catch (Dali::DaliException e) {
35919       {
35920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35921       };
35922     } catch (...) {
35923       {
35924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35925       };
35926     }
35927   }
35928
35929   jresult = result;
35930   return jresult;
35931 }
35932
35933
35934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetResizePolicy(void * jarg1, int jarg2, int jarg3) {
35935   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35936   Dali::ResizePolicy::Type arg2 ;
35937   Dali::Dimension::Type arg3 ;
35938
35939   arg1 = (Dali::Actor *)jarg1;
35940   arg2 = (Dali::ResizePolicy::Type)jarg2;
35941   arg3 = (Dali::Dimension::Type)jarg3;
35942   {
35943     try {
35944       (arg1)->SetResizePolicy(arg2,arg3);
35945     } catch (std::out_of_range& e) {
35946       {
35947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
35948       };
35949     } catch (std::exception& e) {
35950       {
35951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
35952       };
35953     } catch (Dali::DaliException e) {
35954       {
35955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
35956       };
35957     } catch (...) {
35958       {
35959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
35960       };
35961     }
35962   }
35963
35964 }
35965
35966
35967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetResizePolicy(void * jarg1, int jarg2) {
35968   int jresult ;
35969   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
35970   Dali::Dimension::Type arg2 ;
35971   Dali::ResizePolicy::Type result;
35972
35973   arg1 = (Dali::Actor *)jarg1;
35974   arg2 = (Dali::Dimension::Type)jarg2;
35975   {
35976     try {
35977       result = (Dali::ResizePolicy::Type)((Dali::Actor const *)arg1)->GetResizePolicy(arg2);
35978     } catch (std::out_of_range& e) {
35979       {
35980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
35981       };
35982     } catch (std::exception& e) {
35983       {
35984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
35985       };
35986     } catch (Dali::DaliException e) {
35987       {
35988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
35989       };
35990     } catch (...) {
35991       {
35992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
35993       };
35994     }
35995   }
35996
35997   jresult = (int)result;
35998   return jresult;
35999 }
36000
36001
36002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeScalePolicy(void * jarg1, int jarg2) {
36003   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36004   Dali::SizeScalePolicy::Type arg2 ;
36005
36006   arg1 = (Dali::Actor *)jarg1;
36007   arg2 = (Dali::SizeScalePolicy::Type)jarg2;
36008   {
36009     try {
36010       (arg1)->SetProperty( Actor::Property::SIZE_SCALE_POLICY,arg2);
36011     } catch (std::out_of_range& e) {
36012       {
36013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36014       };
36015     } catch (std::exception& e) {
36016       {
36017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36018       };
36019     } catch (Dali::DaliException e) {
36020       {
36021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36022       };
36023     } catch (...) {
36024       {
36025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36026       };
36027     }
36028   }
36029
36030 }
36031
36032
36033 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetSizeScalePolicy(void * jarg1) {
36034   int jresult ;
36035   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36036   Dali::SizeScalePolicy::Type result;
36037
36038   arg1 = (Dali::Actor *)jarg1;
36039   {
36040     try {
36041       result = (Dali::SizeScalePolicy::Type)((Dali::Actor const *)arg1)->GetProperty< SizeScalePolicy::Type >( Actor::Property::SIZE_SCALE_POLICY );
36042     } catch (std::out_of_range& e) {
36043       {
36044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36045       };
36046     } catch (std::exception& e) {
36047       {
36048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36049       };
36050     } catch (Dali::DaliException e) {
36051       {
36052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36053       };
36054     } catch (...) {
36055       {
36056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36057       };
36058     }
36059   }
36060
36061   jresult = (int)result;
36062   return jresult;
36063 }
36064
36065
36066 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetSizeModeFactor(void * jarg1, void * jarg2) {
36067   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36068   Dali::Vector3 *arg2 = 0 ;
36069
36070   arg1 = (Dali::Actor *)jarg1;
36071   arg2 = (Dali::Vector3 *)jarg2;
36072   if (!arg2) {
36073     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
36074     return ;
36075   }
36076   {
36077     try {
36078       (arg1)->SetProperty( Actor::Property::SIZE_MODE_FACTOR, (Dali::Vector3 const &)*arg2);
36079     } catch (std::out_of_range& e) {
36080       {
36081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36082       };
36083     } catch (std::exception& e) {
36084       {
36085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36086       };
36087     } catch (Dali::DaliException e) {
36088       {
36089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36090       };
36091     } catch (...) {
36092       {
36093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36094       };
36095     }
36096   }
36097
36098 }
36099
36100
36101 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetSizeModeFactor(void * jarg1) {
36102   void * jresult ;
36103   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36104   Dali::Vector3 result;
36105
36106   arg1 = (Dali::Actor *)jarg1;
36107   {
36108     try {
36109       result = ((Dali::Actor const *)arg1)->GetProperty< Vector3 >( Actor::Property::SIZE_MODE_FACTOR );
36110     } catch (std::out_of_range& e) {
36111       {
36112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36113       };
36114     } catch (std::exception& e) {
36115       {
36116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36117       };
36118     } catch (Dali::DaliException e) {
36119       {
36120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36121       };
36122     } catch (...) {
36123       {
36124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36125       };
36126     }
36127   }
36128
36129   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
36130   return jresult;
36131 }
36132
36133
36134 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetHeightForWidth(void * jarg1, float jarg2) {
36135   float jresult ;
36136   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36137   float arg2 ;
36138   float result;
36139
36140   arg1 = (Dali::Actor *)jarg1;
36141   arg2 = (float)jarg2;
36142   {
36143     try {
36144       result = (float)(arg1)->GetHeightForWidth(arg2);
36145     } catch (std::out_of_range& e) {
36146       {
36147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36148       };
36149     } catch (std::exception& e) {
36150       {
36151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36152       };
36153     } catch (Dali::DaliException e) {
36154       {
36155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36156       };
36157     } catch (...) {
36158       {
36159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36160       };
36161     }
36162   }
36163
36164   jresult = result;
36165   return jresult;
36166 }
36167
36168
36169 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetWidthForHeight(void * jarg1, float jarg2) {
36170   float jresult ;
36171   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36172   float arg2 ;
36173   float result;
36174
36175   arg1 = (Dali::Actor *)jarg1;
36176   arg2 = (float)jarg2;
36177   {
36178     try {
36179       result = (float)(arg1)->GetWidthForHeight(arg2);
36180     } catch (std::out_of_range& e) {
36181       {
36182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36183       };
36184     } catch (std::exception& e) {
36185       {
36186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36187       };
36188     } catch (Dali::DaliException e) {
36189       {
36190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36191       };
36192     } catch (...) {
36193       {
36194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36195       };
36196     }
36197   }
36198
36199   jresult = result;
36200   return jresult;
36201 }
36202
36203
36204 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Actor_GetRelayoutSize(void * jarg1, int jarg2) {
36205   float jresult ;
36206   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36207   Dali::Dimension::Type arg2 ;
36208   float result;
36209
36210   arg1 = (Dali::Actor *)jarg1;
36211   arg2 = (Dali::Dimension::Type)jarg2;
36212   {
36213     try {
36214       result = (float)((Dali::Actor const *)arg1)->GetRelayoutSize(arg2);
36215     } catch (std::out_of_range& e) {
36216       {
36217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36218       };
36219     } catch (std::exception& e) {
36220       {
36221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36222       };
36223     } catch (Dali::DaliException e) {
36224       {
36225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36226       };
36227     } catch (...) {
36228       {
36229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36230       };
36231     }
36232   }
36233
36234   jresult = result;
36235   return jresult;
36236 }
36237
36238
36239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetPadding(void * jarg1, void * jarg2) {
36240   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36241   Dali::Padding *arg2 = 0 ;
36242
36243   arg1 = (Dali::Actor *)jarg1;
36244   arg2 = (Dali::Padding *)jarg2;
36245   if (!arg2) {
36246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding const & type is null", 0);
36247     return ;
36248   }
36249   {
36250     try {
36251       (arg1)->SetProperty( Actor::Property::PADDING, (Dali::Padding const &)*arg2);
36252     } catch (std::out_of_range& e) {
36253       {
36254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36255       };
36256     } catch (std::exception& e) {
36257       {
36258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36259       };
36260     } catch (Dali::DaliException e) {
36261       {
36262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36263       };
36264     } catch (...) {
36265       {
36266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36267       };
36268     }
36269   }
36270
36271 }
36272
36273
36274 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_GetPadding(void * jarg1, void * jarg2) {
36275   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36276   Dali::Padding *arg2 = 0 ;
36277
36278   arg1 = (Dali::Actor *)jarg1;
36279   arg2 = (Dali::Padding *)jarg2;
36280   if (!arg2) {
36281     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Padding & type is null", 0);
36282     return ;
36283   }
36284   {
36285     try {
36286       *arg2 = ((Dali::Actor const *)arg1)->GetProperty<Vector4>( Actor::Property::PADDING );
36287     } catch (std::out_of_range& e) {
36288       {
36289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36290       };
36291     } catch (std::exception& e) {
36292       {
36293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36294       };
36295     } catch (Dali::DaliException e) {
36296       {
36297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36298       };
36299     } catch (...) {
36300       {
36301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36302       };
36303     }
36304   }
36305
36306 }
36307
36308
36309 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMinimumSize(void * jarg1, void * jarg2) {
36310   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36311   Dali::Vector2 *arg2 = 0 ;
36312
36313   arg1 = (Dali::Actor *)jarg1;
36314   arg2 = (Dali::Vector2 *)jarg2;
36315   if (!arg2) {
36316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36317     return ;
36318   }
36319   {
36320     try {
36321       (arg1)->SetProperty( Actor::Property::MINIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36322     } catch (std::out_of_range& e) {
36323       {
36324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36325       };
36326     } catch (std::exception& e) {
36327       {
36328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36329       };
36330     } catch (Dali::DaliException e) {
36331       {
36332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36333       };
36334     } catch (...) {
36335       {
36336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36337       };
36338     }
36339   }
36340
36341 }
36342
36343
36344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMinimumSize(void * jarg1) {
36345   void * jresult ;
36346   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36347   Dali::Vector2 result;
36348
36349   arg1 = (Dali::Actor *)jarg1;
36350   {
36351     try {
36352       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MINIMUM_SIZE );
36353     } catch (std::out_of_range& e) {
36354       {
36355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36356       };
36357     } catch (std::exception& e) {
36358       {
36359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36360       };
36361     } catch (Dali::DaliException e) {
36362       {
36363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36364       };
36365     } catch (...) {
36366       {
36367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36368       };
36369     }
36370   }
36371
36372   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36373   return jresult;
36374 }
36375
36376
36377 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_SetMaximumSize(void * jarg1, void * jarg2) {
36378   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36379   Dali::Vector2 *arg2 = 0 ;
36380
36381   arg1 = (Dali::Actor *)jarg1;
36382   arg2 = (Dali::Vector2 *)jarg2;
36383   if (!arg2) {
36384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
36385     return ;
36386   }
36387   {
36388     try {
36389       (arg1)->SetProperty( Actor::Property::MAXIMUM_SIZE,(Dali::Vector2 const &)*arg2);
36390     } catch (std::out_of_range& e) {
36391       {
36392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36393       };
36394     } catch (std::exception& e) {
36395       {
36396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36397       };
36398     } catch (Dali::DaliException e) {
36399       {
36400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36401       };
36402     } catch (...) {
36403       {
36404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36405       };
36406     }
36407   }
36408
36409 }
36410
36411
36412 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetMaximumSize(void * jarg1) {
36413   void * jresult ;
36414   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36415   Dali::Vector2 result;
36416
36417   arg1 = (Dali::Actor *)jarg1;
36418   {
36419     try {
36420       result = (arg1)->GetProperty< Vector2 >( Actor::Property::MAXIMUM_SIZE );
36421     } catch (std::out_of_range& e) {
36422       {
36423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36424       };
36425     } catch (std::exception& e) {
36426       {
36427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36428       };
36429     } catch (Dali::DaliException e) {
36430       {
36431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36432       };
36433     } catch (...) {
36434       {
36435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36436       };
36437     }
36438   }
36439
36440   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
36441   return jresult;
36442 }
36443
36444
36445 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Actor_GetHierarchyDepth(void * jarg1) {
36446   int jresult ;
36447   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36448   int result;
36449
36450   arg1 = (Dali::Actor *)jarg1;
36451   {
36452     try {
36453       result = (int)(arg1)->GetProperty< int >( Actor::Property::HIERARCHY_DEPTH );
36454       Dali::Actor parent = ((Dali::Actor const *)arg1)->GetParent();
36455     } catch (std::out_of_range& e) {
36456       {
36457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36458       };
36459     } catch (std::exception& e) {
36460       {
36461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36462       };
36463     } catch (Dali::DaliException e) {
36464       {
36465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36466       };
36467     } catch (...) {
36468       {
36469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36470       };
36471     }
36472   }
36473
36474   jresult = result;
36475   return jresult;
36476 }
36477
36478
36479 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_AddRenderer(void * jarg1, void * jarg2) {
36480   unsigned int jresult ;
36481   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36482   Dali::Renderer *arg2 = 0 ;
36483   unsigned int result;
36484
36485   arg1 = (Dali::Actor *)jarg1;
36486   arg2 = (Dali::Renderer *)jarg2;
36487   if (!arg2) {
36488     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36489     return 0;
36490   }
36491   {
36492     try {
36493       result = (unsigned int)(arg1)->AddRenderer(*arg2);
36494     } catch (std::out_of_range& e) {
36495       {
36496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36497       };
36498     } catch (std::exception& e) {
36499       {
36500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36501       };
36502     } catch (Dali::DaliException e) {
36503       {
36504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36505       };
36506     } catch (...) {
36507       {
36508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36509       };
36510     }
36511   }
36512
36513   jresult = result;
36514   return jresult;
36515 }
36516
36517
36518 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Actor_GetRendererCount(void * jarg1) {
36519   unsigned int jresult ;
36520   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36521   unsigned int result;
36522
36523   arg1 = (Dali::Actor *)jarg1;
36524   {
36525     try {
36526       result = (unsigned int)((Dali::Actor const *)arg1)->GetRendererCount();
36527     } catch (std::out_of_range& e) {
36528       {
36529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36530       };
36531     } catch (std::exception& e) {
36532       {
36533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36534       };
36535     } catch (Dali::DaliException e) {
36536       {
36537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36538       };
36539     } catch (...) {
36540       {
36541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36542       };
36543     }
36544   }
36545
36546   jresult = result;
36547   return jresult;
36548 }
36549
36550
36551 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_GetRendererAt(void * jarg1, unsigned int jarg2) {
36552   void * jresult ;
36553   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36554   unsigned int arg2 ;
36555   Dali::Renderer result;
36556
36557   arg1 = (Dali::Actor *)jarg1;
36558   arg2 = (unsigned int)jarg2;
36559   {
36560     try {
36561       result = (arg1)->GetRendererAt(arg2);
36562     } catch (std::out_of_range& e) {
36563       {
36564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36565       };
36566     } catch (std::exception& e) {
36567       {
36568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36569       };
36570     } catch (Dali::DaliException e) {
36571       {
36572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36573       };
36574     } catch (...) {
36575       {
36576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36577       };
36578     }
36579   }
36580
36581   jresult = new Dali::Renderer((const Dali::Renderer &)result);
36582   return jresult;
36583 }
36584
36585
36586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_0(void * jarg1, void * jarg2) {
36587   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36588   Dali::Renderer *arg2 = 0 ;
36589
36590   arg1 = (Dali::Actor *)jarg1;
36591   arg2 = (Dali::Renderer *)jarg2;
36592   if (!arg2) {
36593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Renderer & type is null", 0);
36594     return ;
36595   }
36596   {
36597     try {
36598       (arg1)->RemoveRenderer(*arg2);
36599     } catch (std::out_of_range& e) {
36600       {
36601         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36602       };
36603     } catch (std::exception& e) {
36604       {
36605         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36606       };
36607     } catch (Dali::DaliException e) {
36608       {
36609         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36610       };
36611     } catch (...) {
36612       {
36613         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36614       };
36615     }
36616   }
36617
36618 }
36619
36620
36621 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Actor_RemoveRenderer__SWIG_1(void * jarg1, unsigned int jarg2) {
36622   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36623   unsigned int arg2 ;
36624
36625   arg1 = (Dali::Actor *)jarg1;
36626   arg2 = (unsigned int)jarg2;
36627   {
36628     try {
36629       (arg1)->RemoveRenderer(arg2);
36630     } catch (std::out_of_range& e) {
36631       {
36632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36633       };
36634     } catch (std::exception& e) {
36635       {
36636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36637       };
36638     } catch (Dali::DaliException e) {
36639       {
36640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36641       };
36642     } catch (...) {
36643       {
36644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36645       };
36646     }
36647   }
36648
36649 }
36650
36651
36652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_TouchSignal(void * jarg1) {
36653   void * jresult ;
36654   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36655   Dali::Actor::TouchDataSignalType *result = 0 ;
36656
36657   arg1 = (Dali::Actor *)jarg1;
36658   {
36659     try {
36660       result = (Dali::Actor::TouchDataSignalType *) &(arg1)->TouchSignal();
36661     } catch (std::out_of_range& e) {
36662       {
36663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36664       };
36665     } catch (std::exception& e) {
36666       {
36667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36668       };
36669     } catch (Dali::DaliException e) {
36670       {
36671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36672       };
36673     } catch (...) {
36674       {
36675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36676       };
36677     }
36678   }
36679
36680   jresult = (void *)result;
36681   return jresult;
36682 }
36683
36684
36685 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_HoveredSignal(void * jarg1) {
36686   void * jresult ;
36687   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36688   Dali::Actor::HoverSignalType *result = 0 ;
36689
36690   arg1 = (Dali::Actor *)jarg1;
36691   {
36692     try {
36693       result = (Dali::Actor::HoverSignalType *) &(arg1)->HoveredSignal();
36694     } catch (std::out_of_range& e) {
36695       {
36696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36697       };
36698     } catch (std::exception& e) {
36699       {
36700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36701       };
36702     } catch (Dali::DaliException e) {
36703       {
36704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36705       };
36706     } catch (...) {
36707       {
36708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36709       };
36710     }
36711   }
36712
36713   jresult = (void *)result;
36714   return jresult;
36715 }
36716
36717
36718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_WheelEventSignal(void * jarg1) {
36719   void * jresult ;
36720   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36721   Dali::Actor::WheelEventSignalType *result = 0 ;
36722
36723   arg1 = (Dali::Actor *)jarg1;
36724   {
36725     try {
36726       result = (Dali::Actor::WheelEventSignalType *) &(arg1)->WheelEventSignal();
36727     } catch (std::out_of_range& e) {
36728       {
36729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36730       };
36731     } catch (std::exception& e) {
36732       {
36733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36734       };
36735     } catch (Dali::DaliException e) {
36736       {
36737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36738       };
36739     } catch (...) {
36740       {
36741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36742       };
36743     }
36744   }
36745
36746   jresult = (void *)result;
36747   return jresult;
36748 }
36749
36750
36751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnStageSignal(void * jarg1) {
36752   void * jresult ;
36753   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36754   Dali::Actor::OnStageSignalType *result = 0 ;
36755
36756   arg1 = (Dali::Actor *)jarg1;
36757   {
36758     try {
36759       result = (Dali::Actor::OnStageSignalType *) &(arg1)->OnStageSignal();
36760     } catch (std::out_of_range& e) {
36761       {
36762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36763       };
36764     } catch (std::exception& e) {
36765       {
36766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36767       };
36768     } catch (Dali::DaliException e) {
36769       {
36770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36771       };
36772     } catch (...) {
36773       {
36774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36775       };
36776     }
36777   }
36778
36779   jresult = (void *)result;
36780   return jresult;
36781 }
36782
36783
36784 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OffStageSignal(void * jarg1) {
36785   void * jresult ;
36786   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36787   Dali::Actor::OffStageSignalType *result = 0 ;
36788
36789   arg1 = (Dali::Actor *)jarg1;
36790   {
36791     try {
36792       result = (Dali::Actor::OffStageSignalType *) &(arg1)->OffStageSignal();
36793     } catch (std::out_of_range& e) {
36794       {
36795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36796       };
36797     } catch (std::exception& e) {
36798       {
36799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36800       };
36801     } catch (Dali::DaliException e) {
36802       {
36803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36804       };
36805     } catch (...) {
36806       {
36807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36808       };
36809     }
36810   }
36811
36812   jresult = (void *)result;
36813   return jresult;
36814 }
36815
36816
36817 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Actor_OnRelayoutSignal(void * jarg1) {
36818   void * jresult ;
36819   Dali::Actor *arg1 = (Dali::Actor *) 0 ;
36820   Dali::Actor::OnRelayoutSignalType *result = 0 ;
36821
36822   arg1 = (Dali::Actor *)jarg1;
36823   {
36824     try {
36825       result = (Dali::Actor::OnRelayoutSignalType *) &(arg1)->OnRelayoutSignal();
36826     } catch (std::out_of_range& e) {
36827       {
36828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36829       };
36830     } catch (std::exception& e) {
36831       {
36832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36833       };
36834     } catch (Dali::DaliException e) {
36835       {
36836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36837       };
36838     } catch (...) {
36839       {
36840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36841       };
36842     }
36843   }
36844
36845   jresult = (void *)result;
36846   return jresult;
36847 }
36848
36849
36850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_UnparentAndReset(void * jarg1) {
36851   Dali::Actor *arg1 = 0 ;
36852
36853   arg1 = (Dali::Actor *)jarg1;
36854   if (!arg1) {
36855     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
36856     return ;
36857   }
36858   {
36859     try {
36860       Dali::UnparentAndReset(*arg1);
36861     } catch (std::out_of_range& e) {
36862       {
36863         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36864       };
36865     } catch (std::exception& e) {
36866       {
36867         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36868       };
36869     } catch (Dali::DaliException e) {
36870       {
36871         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36872       };
36873     } catch (...) {
36874       {
36875         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36876       };
36877     }
36878   }
36879
36880 }
36881
36882
36883 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_ENABLE_get() {
36884   int jresult ;
36885   int result;
36886
36887   result = (int)Dali::Layer::Property::CLIPPING_ENABLE;
36888   jresult = (int)result;
36889   return jresult;
36890 }
36891
36892
36893 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_CLIPPING_BOX_get() {
36894   int jresult ;
36895   int result;
36896
36897   result = (int)Dali::Layer::Property::CLIPPING_BOX;
36898   jresult = (int)result;
36899   return jresult;
36900 }
36901
36902
36903 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_Property_BEHAVIOR_get() {
36904   int jresult ;
36905   int result;
36906
36907   result = (int)Dali::Layer::Property::BEHAVIOR;
36908   jresult = (int)result;
36909   return jresult;
36910 }
36911
36912
36913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer_Property() {
36914   void * jresult ;
36915   Dali::Layer::Property *result = 0 ;
36916
36917   {
36918     try {
36919       result = (Dali::Layer::Property *)new Dali::Layer::Property();
36920     } catch (std::out_of_range& e) {
36921       {
36922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36923       };
36924     } catch (std::exception& e) {
36925       {
36926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36927       };
36928     } catch (Dali::DaliException e) {
36929       {
36930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36931       };
36932     } catch (...) {
36933       {
36934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36935       };
36936     }
36937   }
36938
36939   jresult = (void *)result;
36940   return jresult;
36941 }
36942
36943
36944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer_Property(void * jarg1) {
36945   Dali::Layer::Property *arg1 = (Dali::Layer::Property *) 0 ;
36946
36947   arg1 = (Dali::Layer::Property *)jarg1;
36948   {
36949     try {
36950       delete arg1;
36951     } catch (std::out_of_range& e) {
36952       {
36953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
36954       };
36955     } catch (std::exception& e) {
36956       {
36957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
36958       };
36959     } catch (Dali::DaliException e) {
36960       {
36961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
36962       };
36963     } catch (...) {
36964       {
36965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
36966       };
36967     }
36968   }
36969
36970 }
36971
36972
36973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_0() {
36974   void * jresult ;
36975   Dali::Layer *result = 0 ;
36976
36977   {
36978     try {
36979       result = (Dali::Layer *)new Dali::Layer();
36980     } catch (std::out_of_range& e) {
36981       {
36982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
36983       };
36984     } catch (std::exception& e) {
36985       {
36986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
36987       };
36988     } catch (Dali::DaliException e) {
36989       {
36990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
36991       };
36992     } catch (...) {
36993       {
36994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
36995       };
36996     }
36997   }
36998
36999   jresult = (void *)result;
37000   return jresult;
37001 }
37002
37003
37004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_New() {
37005   void * jresult ;
37006   Dali::Layer result;
37007
37008   {
37009     try {
37010       result = Dali::Layer::New();
37011     } catch (std::out_of_range& e) {
37012       {
37013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37014       };
37015     } catch (std::exception& e) {
37016       {
37017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37018       };
37019     } catch (Dali::DaliException e) {
37020       {
37021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37022       };
37023     } catch (...) {
37024       {
37025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37026       };
37027     }
37028   }
37029
37030   jresult = new Dali::Layer((const Dali::Layer &)result);
37031   return jresult;
37032 }
37033
37034
37035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_DownCast(void * jarg1) {
37036   void * jresult ;
37037   Dali::BaseHandle arg1 ;
37038   Dali::BaseHandle *argp1 ;
37039   Dali::Layer result;
37040
37041   argp1 = (Dali::BaseHandle *)jarg1;
37042   if (!argp1) {
37043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
37044     return 0;
37045   }
37046   arg1 = *argp1;
37047   {
37048     try {
37049       result = Dali::Layer::DownCast(arg1);
37050     } catch (std::out_of_range& e) {
37051       {
37052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37053       };
37054     } catch (std::exception& e) {
37055       {
37056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37057       };
37058     } catch (Dali::DaliException e) {
37059       {
37060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37061       };
37062     } catch (...) {
37063       {
37064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37065       };
37066     }
37067   }
37068
37069   jresult = new Dali::Layer((const Dali::Layer &)result);
37070   return jresult;
37071 }
37072
37073
37074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Layer(void * jarg1) {
37075   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37076
37077   arg1 = (Dali::Layer *)jarg1;
37078   {
37079     try {
37080       delete arg1;
37081     } catch (std::out_of_range& e) {
37082       {
37083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37084       };
37085     } catch (std::exception& e) {
37086       {
37087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37088       };
37089     } catch (Dali::DaliException e) {
37090       {
37091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37092       };
37093     } catch (...) {
37094       {
37095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37096       };
37097     }
37098   }
37099
37100 }
37101
37102
37103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Layer__SWIG_1(void * jarg1) {
37104   void * jresult ;
37105   Dali::Layer *arg1 = 0 ;
37106   Dali::Layer *result = 0 ;
37107
37108   arg1 = (Dali::Layer *)jarg1;
37109   if (!arg1) {
37110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37111     return 0;
37112   }
37113   {
37114     try {
37115       result = (Dali::Layer *)new Dali::Layer((Dali::Layer const &)*arg1);
37116     } catch (std::out_of_range& e) {
37117       {
37118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37119       };
37120     } catch (std::exception& e) {
37121       {
37122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37123       };
37124     } catch (Dali::DaliException e) {
37125       {
37126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37127       };
37128     } catch (...) {
37129       {
37130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37131       };
37132     }
37133   }
37134
37135   jresult = (void *)result;
37136   return jresult;
37137 }
37138
37139
37140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_Assign(void * jarg1, void * jarg2) {
37141   void * jresult ;
37142   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37143   Dali::Layer *arg2 = 0 ;
37144   Dali::Layer *result = 0 ;
37145
37146   arg1 = (Dali::Layer *)jarg1;
37147   arg2 = (Dali::Layer *)jarg2;
37148   if (!arg2) {
37149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Layer const & type is null", 0);
37150     return 0;
37151   }
37152   {
37153     try {
37154       result = (Dali::Layer *) &(arg1)->operator =((Dali::Layer const &)*arg2);
37155     } catch (std::out_of_range& e) {
37156       {
37157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37158       };
37159     } catch (std::exception& e) {
37160       {
37161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37162       };
37163     } catch (Dali::DaliException e) {
37164       {
37165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37166       };
37167     } catch (...) {
37168       {
37169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37170       };
37171     }
37172   }
37173
37174   jresult = (void *)result;
37175   return jresult;
37176 }
37177
37178
37179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_GetDepth(void * jarg1) {
37180   unsigned int jresult ;
37181   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37182   unsigned int result;
37183
37184   arg1 = (Dali::Layer *)jarg1;
37185   {
37186     try {
37187       result = (unsigned int)((Dali::Layer const *)arg1)->GetProperty< int >( Layer::Property::DEPTH );
37188     } catch (std::out_of_range& e) {
37189       {
37190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37191       };
37192     } catch (std::exception& e) {
37193       {
37194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37195       };
37196     } catch (Dali::DaliException e) {
37197       {
37198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37199       };
37200     } catch (...) {
37201       {
37202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37203       };
37204     }
37205   }
37206
37207   jresult = result;
37208   return jresult;
37209 }
37210
37211
37212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Raise(void * jarg1) {
37213   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37214
37215   arg1 = (Dali::Layer *)jarg1;
37216   {
37217     try {
37218       (arg1)->Raise();
37219     } catch (std::out_of_range& e) {
37220       {
37221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37222       };
37223     } catch (std::exception& e) {
37224       {
37225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37226       };
37227     } catch (Dali::DaliException e) {
37228       {
37229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37230       };
37231     } catch (...) {
37232       {
37233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37234       };
37235     }
37236   }
37237
37238 }
37239
37240
37241 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_Lower(void * jarg1) {
37242   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37243
37244   arg1 = (Dali::Layer *)jarg1;
37245   {
37246     try {
37247       (arg1)->Lower();
37248     } catch (std::out_of_range& e) {
37249       {
37250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37251       };
37252     } catch (std::exception& e) {
37253       {
37254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37255       };
37256     } catch (Dali::DaliException e) {
37257       {
37258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37259       };
37260     } catch (...) {
37261       {
37262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37263       };
37264     }
37265   }
37266
37267 }
37268
37269
37270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseAbove(void * jarg1, void * jarg2) {
37271   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37272   Dali::Layer arg2 ;
37273   Dali::Layer *argp2 ;
37274
37275   arg1 = (Dali::Layer *)jarg1;
37276   argp2 = (Dali::Layer *)jarg2;
37277   if (!argp2) {
37278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37279     return ;
37280   }
37281   arg2 = *argp2;
37282   {
37283     try {
37284       (arg1)->RaiseAbove(arg2);
37285     } catch (std::out_of_range& e) {
37286       {
37287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37288       };
37289     } catch (std::exception& e) {
37290       {
37291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37292       };
37293     } catch (Dali::DaliException e) {
37294       {
37295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37296       };
37297     } catch (...) {
37298       {
37299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37300       };
37301     }
37302   }
37303
37304 }
37305
37306
37307 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerBelow(void * jarg1, void * jarg2) {
37308   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37309   Dali::Layer arg2 ;
37310   Dali::Layer *argp2 ;
37311
37312   arg1 = (Dali::Layer *)jarg1;
37313   argp2 = (Dali::Layer *)jarg2;
37314   if (!argp2) {
37315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37316     return ;
37317   }
37318   arg2 = *argp2;
37319   {
37320     try {
37321       (arg1)->LowerBelow(arg2);
37322     } catch (std::out_of_range& e) {
37323       {
37324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37325       };
37326     } catch (std::exception& e) {
37327       {
37328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37329       };
37330     } catch (Dali::DaliException e) {
37331       {
37332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37333       };
37334     } catch (...) {
37335       {
37336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37337       };
37338     }
37339   }
37340
37341 }
37342
37343
37344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_RaiseToTop(void * jarg1) {
37345   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37346
37347   arg1 = (Dali::Layer *)jarg1;
37348   {
37349     try {
37350       (arg1)->RaiseToTop();
37351     } catch (std::out_of_range& e) {
37352       {
37353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37354       };
37355     } catch (std::exception& e) {
37356       {
37357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37358       };
37359     } catch (Dali::DaliException e) {
37360       {
37361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37362       };
37363     } catch (...) {
37364       {
37365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37366       };
37367     }
37368   }
37369
37370 }
37371
37372
37373 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_LowerToBottom(void * jarg1) {
37374   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37375
37376   arg1 = (Dali::Layer *)jarg1;
37377   {
37378     try {
37379       (arg1)->LowerToBottom();
37380     } catch (std::out_of_range& e) {
37381       {
37382         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37383       };
37384     } catch (std::exception& e) {
37385       {
37386         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37387       };
37388     } catch (Dali::DaliException e) {
37389       {
37390         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37391       };
37392     } catch (...) {
37393       {
37394         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37395       };
37396     }
37397   }
37398
37399 }
37400
37401
37402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveAbove(void * jarg1, void * jarg2) {
37403   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37404   Dali::Layer arg2 ;
37405   Dali::Layer *argp2 ;
37406
37407   arg1 = (Dali::Layer *)jarg1;
37408   argp2 = (Dali::Layer *)jarg2;
37409   if (!argp2) {
37410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37411     return ;
37412   }
37413   arg2 = *argp2;
37414   {
37415     try {
37416       (arg1)->MoveAbove(arg2);
37417     } catch (std::out_of_range& e) {
37418       {
37419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37420       };
37421     } catch (std::exception& e) {
37422       {
37423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37424       };
37425     } catch (Dali::DaliException e) {
37426       {
37427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37428       };
37429     } catch (...) {
37430       {
37431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37432       };
37433     }
37434   }
37435
37436 }
37437
37438
37439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_MoveBelow(void * jarg1, void * jarg2) {
37440   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37441   Dali::Layer arg2 ;
37442   Dali::Layer *argp2 ;
37443
37444   arg1 = (Dali::Layer *)jarg1;
37445   argp2 = (Dali::Layer *)jarg2;
37446   if (!argp2) {
37447     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Layer", 0);
37448     return ;
37449   }
37450   arg2 = *argp2;
37451   {
37452     try {
37453       (arg1)->MoveBelow(arg2);
37454     } catch (std::out_of_range& e) {
37455       {
37456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37457       };
37458     } catch (std::exception& e) {
37459       {
37460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37461       };
37462     } catch (Dali::DaliException e) {
37463       {
37464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37465       };
37466     } catch (...) {
37467       {
37468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37469       };
37470     }
37471   }
37472
37473 }
37474
37475
37476 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetBehavior(void * jarg1, int jarg2) {
37477   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37478   Dali::Layer::Behavior arg2 ;
37479
37480   arg1 = (Dali::Layer *)jarg1;
37481   arg2 = (Dali::Layer::Behavior)jarg2;
37482   {
37483     try {
37484       (arg1)->SetProperty( Layer::Property::BEHAVIOR, arg2 );
37485     } catch (std::out_of_range& e) {
37486       {
37487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37488       };
37489     } catch (std::exception& e) {
37490       {
37491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37492       };
37493     } catch (Dali::DaliException e) {
37494       {
37495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37496       };
37497     } catch (...) {
37498       {
37499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37500       };
37501     }
37502   }
37503
37504 }
37505
37506
37507 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Layer_GetBehavior(void * jarg1) {
37508   int jresult ;
37509   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37510   Dali::Layer::Behavior result;
37511
37512   arg1 = (Dali::Layer *)jarg1;
37513   {
37514     try {
37515       result = (Dali::Layer::Behavior)((Dali::Layer const *)arg1)->GetProperty<Dali::Layer::Behavior>( Dali::Layer::Property::BEHAVIOR );
37516     } catch (std::out_of_range& e) {
37517       {
37518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37519       };
37520     } catch (std::exception& e) {
37521       {
37522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37523       };
37524     } catch (Dali::DaliException e) {
37525       {
37526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37527       };
37528     } catch (...) {
37529       {
37530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37531       };
37532     }
37533   }
37534
37535   jresult = (int)result;
37536   return jresult;
37537 }
37538
37539
37540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClipping(void * jarg1, unsigned int jarg2) {
37541   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37542   bool arg2 ;
37543
37544   arg1 = (Dali::Layer *)jarg1;
37545   arg2 = jarg2 ? true : false;
37546   {
37547     try {
37548       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_ENABLE, arg2 );
37549     } catch (std::out_of_range& e) {
37550       {
37551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37552       };
37553     } catch (std::exception& e) {
37554       {
37555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37556       };
37557     } catch (Dali::DaliException e) {
37558       {
37559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37560       };
37561     } catch (...) {
37562       {
37563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37564       };
37565     }
37566   }
37567
37568 }
37569
37570
37571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsClipping(void * jarg1) {
37572   unsigned int jresult ;
37573   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37574   bool result;
37575
37576   arg1 = (Dali::Layer *)jarg1;
37577   {
37578     try {
37579       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Dali::Layer::Property::CLIPPING_ENABLE );
37580     } catch (std::out_of_range& e) {
37581       {
37582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37583       };
37584     } catch (std::exception& e) {
37585       {
37586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37587       };
37588     } catch (Dali::DaliException e) {
37589       {
37590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37591       };
37592     } catch (...) {
37593       {
37594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37595       };
37596     }
37597   }
37598
37599   jresult = result;
37600   return jresult;
37601 }
37602
37603
37604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_0(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
37605   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37606   int arg2 ;
37607   int arg3 ;
37608   int arg4 ;
37609   int arg5 ;
37610
37611   arg1 = (Dali::Layer *)jarg1;
37612   arg2 = (int)jarg2;
37613   arg3 = (int)jarg3;
37614   arg4 = (int)jarg4;
37615   arg5 = (int)jarg5;
37616   {
37617     try {
37618       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, Rect<int32_t>( arg2,arg3,arg4,arg5 ) );
37619     } catch (std::out_of_range& e) {
37620       {
37621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37622       };
37623     } catch (std::exception& e) {
37624       {
37625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37626       };
37627     } catch (Dali::DaliException e) {
37628       {
37629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37630       };
37631     } catch (...) {
37632       {
37633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37634       };
37635     }
37636   }
37637
37638 }
37639
37640
37641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetClippingBox__SWIG_1(void * jarg1, void * jarg2) {
37642   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37643   Dali::ClippingBox arg2 ;
37644   Dali::ClippingBox *argp2 ;
37645
37646   arg1 = (Dali::Layer *)jarg1;
37647   argp2 = (Dali::ClippingBox *)jarg2;
37648   if (!argp2) {
37649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ClippingBox", 0);
37650     return ;
37651   }
37652   arg2 = *argp2;
37653   {
37654     try {
37655       (arg1)->SetProperty( Dali::Layer::Property::CLIPPING_BOX, arg2 );
37656     } catch (std::out_of_range& e) {
37657       {
37658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37659       };
37660     } catch (std::exception& e) {
37661       {
37662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37663       };
37664     } catch (Dali::DaliException e) {
37665       {
37666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37667       };
37668     } catch (...) {
37669       {
37670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37671       };
37672     }
37673   }
37674
37675 }
37676
37677
37678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Layer_GetClippingBox(void * jarg1) {
37679   void * jresult ;
37680   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37681   Dali::ClippingBox result;
37682
37683   arg1 = (Dali::Layer *)jarg1;
37684   {
37685     try {
37686       result = ((Dali::Layer const *)arg1)->GetProperty< Rect<int32_t> >( Layer::Property::CLIPPING_BOX );
37687     } catch (std::out_of_range& e) {
37688       {
37689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37690       };
37691     } catch (std::exception& e) {
37692       {
37693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37694       };
37695     } catch (Dali::DaliException e) {
37696       {
37697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37698       };
37699     } catch (...) {
37700       {
37701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37702       };
37703     }
37704   }
37705
37706   jresult = new Dali::ClippingBox((const Dali::ClippingBox &)result);
37707   return jresult;
37708 }
37709
37710
37711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetDepthTestDisabled(void * jarg1, unsigned int jarg2) {
37712   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37713   bool arg2 ;
37714
37715   arg1 = (Dali::Layer *)jarg1;
37716   arg2 = jarg2 ? true : false;
37717   {
37718     try {
37719       (arg1)->SetProperty( Layer::Property::DEPTH_TEST, !arg2 );
37720     } catch (std::out_of_range& e) {
37721       {
37722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37723       };
37724     } catch (std::exception& e) {
37725       {
37726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37727       };
37728     } catch (Dali::DaliException e) {
37729       {
37730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37731       };
37732     } catch (...) {
37733       {
37734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37735       };
37736     }
37737   }
37738
37739 }
37740
37741
37742 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsDepthTestDisabled(void * jarg1) {
37743   unsigned int jresult ;
37744   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37745   bool result;
37746
37747   arg1 = (Dali::Layer *)jarg1;
37748   {
37749     try {
37750       result = !(bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::DEPTH_TEST );
37751     } catch (std::out_of_range& e) {
37752       {
37753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37754       };
37755     } catch (std::exception& e) {
37756       {
37757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37758       };
37759     } catch (Dali::DaliException e) {
37760       {
37761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37762       };
37763     } catch (...) {
37764       {
37765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37766       };
37767     }
37768   }
37769
37770   jresult = result;
37771   return jresult;
37772 }
37773
37774
37775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetSortFunction(void * jarg1, void * jarg2) {
37776   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37777   Dali::Layer::SortFunctionType arg2 = (Dali::Layer::SortFunctionType) 0 ;
37778
37779   arg1 = (Dali::Layer *)jarg1;
37780   arg2 = (Dali::Layer::SortFunctionType)jarg2;
37781   {
37782     try {
37783       (arg1)->SetSortFunction(arg2);
37784     } catch (std::out_of_range& e) {
37785       {
37786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37787       };
37788     } catch (std::exception& e) {
37789       {
37790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37791       };
37792     } catch (Dali::DaliException e) {
37793       {
37794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37795       };
37796     } catch (...) {
37797       {
37798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37799       };
37800     }
37801   }
37802
37803 }
37804
37805
37806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetTouchConsumed(void * jarg1, unsigned int jarg2) {
37807   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37808   bool arg2 ;
37809
37810   arg1 = (Dali::Layer *)jarg1;
37811   arg2 = jarg2 ? true : false;
37812   {
37813     try {
37814       (arg1)->SetProperty( Layer::Property::CONSUMES_TOUCH, arg2 );
37815     } catch (std::out_of_range& e) {
37816       {
37817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37818       };
37819     } catch (std::exception& e) {
37820       {
37821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37822       };
37823     } catch (Dali::DaliException e) {
37824       {
37825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37826       };
37827     } catch (...) {
37828       {
37829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37830       };
37831     }
37832   }
37833
37834 }
37835
37836
37837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsTouchConsumed(void * jarg1) {
37838   unsigned int jresult ;
37839   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37840   bool result;
37841
37842   arg1 = (Dali::Layer *)jarg1;
37843   {
37844     try {
37845       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_TOUCH );
37846     } catch (std::out_of_range& e) {
37847       {
37848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37849       };
37850     } catch (std::exception& e) {
37851       {
37852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37853       };
37854     } catch (Dali::DaliException e) {
37855       {
37856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37857       };
37858     } catch (...) {
37859       {
37860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37861       };
37862     }
37863   }
37864
37865   jresult = result;
37866   return jresult;
37867 }
37868
37869
37870 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Layer_SetHoverConsumed(void * jarg1, unsigned int jarg2) {
37871   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37872   bool arg2 ;
37873
37874   arg1 = (Dali::Layer *)jarg1;
37875   arg2 = jarg2 ? true : false;
37876   {
37877     try {
37878       (arg1)->SetProperty( Layer::Property::CONSUMES_HOVER, arg2 );
37879     } catch (std::out_of_range& e) {
37880       {
37881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
37882       };
37883     } catch (std::exception& e) {
37884       {
37885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
37886       };
37887     } catch (Dali::DaliException e) {
37888       {
37889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
37890       };
37891     } catch (...) {
37892       {
37893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
37894       };
37895     }
37896   }
37897
37898 }
37899
37900
37901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Layer_IsHoverConsumed(void * jarg1) {
37902   unsigned int jresult ;
37903   Dali::Layer *arg1 = (Dali::Layer *) 0 ;
37904   bool result;
37905
37906   arg1 = (Dali::Layer *)jarg1;
37907   {
37908     try {
37909       result = (bool)((Dali::Layer const *)arg1)->GetProperty< bool >( Layer::Property::CONSUMES_HOVER );
37910     } catch (std::out_of_range& e) {
37911       {
37912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37913       };
37914     } catch (std::exception& e) {
37915       {
37916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37917       };
37918     } catch (Dali::DaliException e) {
37919       {
37920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37921       };
37922     } catch (...) {
37923       {
37924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37925       };
37926     }
37927   }
37928
37929   jresult = result;
37930   return jresult;
37931 }
37932
37933
37934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEFAULT_BACKGROUND_COLOR_get() {
37935   void * jresult ;
37936   Dali::Vector4 *result = 0 ;
37937
37938   result = (Dali::Vector4 *)&Dali::Stage::DEFAULT_BACKGROUND_COLOR;
37939   jresult = (void *)result;
37940   return jresult;
37941 }
37942
37943
37944 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_DEBUG_BACKGROUND_COLOR_get() {
37945   void * jresult ;
37946   Dali::Vector4 *result = 0 ;
37947
37948   result = (Dali::Vector4 *)&Dali::Stage::DEBUG_BACKGROUND_COLOR;
37949   jresult = (void *)result;
37950   return jresult;
37951 }
37952
37953
37954 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_0() {
37955   void * jresult ;
37956   Dali::Stage *result = 0 ;
37957
37958   {
37959     try {
37960       result = (Dali::Stage *)new Dali::Stage();
37961     } catch (std::out_of_range& e) {
37962       {
37963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37964       };
37965     } catch (std::exception& e) {
37966       {
37967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37968       };
37969     } catch (Dali::DaliException e) {
37970       {
37971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37972       };
37973     } catch (...) {
37974       {
37975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37976       };
37977     }
37978   }
37979
37980   jresult = (void *)result;
37981   return jresult;
37982 }
37983
37984
37985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetCurrent() {
37986   void * jresult ;
37987   Dali::Stage result;
37988
37989   {
37990     try {
37991       result = Dali::Stage::GetCurrent();
37992     } catch (std::out_of_range& e) {
37993       {
37994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37995       };
37996     } catch (std::exception& e) {
37997       {
37998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37999       };
38000     } catch (Dali::DaliException e) {
38001       {
38002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38003       };
38004     } catch (...) {
38005       {
38006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38007       };
38008     }
38009   }
38010
38011   jresult = new Dali::Stage((const Dali::Stage &)result);
38012   return jresult;
38013 }
38014
38015
38016 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
38017   unsigned int jresult ;
38018   bool result;
38019
38020   {
38021     try {
38022       result = (bool)Dali::Stage::IsInstalled();
38023     } catch (std::out_of_range& e) {
38024       {
38025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38026       };
38027     } catch (std::exception& e) {
38028       {
38029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38030       };
38031     } catch (Dali::DaliException e) {
38032       {
38033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38034       };
38035     } catch (...) {
38036       {
38037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38038       };
38039     }
38040   }
38041
38042   jresult = result;
38043   return jresult;
38044 }
38045
38046
38047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Stage(void * jarg1) {
38048   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38049
38050   arg1 = (Dali::Stage *)jarg1;
38051   {
38052     try {
38053       delete arg1;
38054     } catch (std::out_of_range& e) {
38055       {
38056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38057       };
38058     } catch (std::exception& e) {
38059       {
38060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38061       };
38062     } catch (Dali::DaliException e) {
38063       {
38064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38065       };
38066     } catch (...) {
38067       {
38068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38069       };
38070     }
38071   }
38072
38073 }
38074
38075
38076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Stage__SWIG_1(void * jarg1) {
38077   void * jresult ;
38078   Dali::Stage *arg1 = 0 ;
38079   Dali::Stage *result = 0 ;
38080
38081   arg1 = (Dali::Stage *)jarg1;
38082   if (!arg1) {
38083     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38084     return 0;
38085   }
38086   {
38087     try {
38088       result = (Dali::Stage *)new Dali::Stage((Dali::Stage const &)*arg1);
38089     } catch (std::out_of_range& e) {
38090       {
38091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38092       };
38093     } catch (std::exception& e) {
38094       {
38095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38096       };
38097     } catch (Dali::DaliException e) {
38098       {
38099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38100       };
38101     } catch (...) {
38102       {
38103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38104       };
38105     }
38106   }
38107
38108   jresult = (void *)result;
38109   return jresult;
38110 }
38111
38112
38113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_Assign(void * jarg1, void * jarg2) {
38114   void * jresult ;
38115   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38116   Dali::Stage *arg2 = 0 ;
38117   Dali::Stage *result = 0 ;
38118
38119   arg1 = (Dali::Stage *)jarg1;
38120   arg2 = (Dali::Stage *)jarg2;
38121   if (!arg2) {
38122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Stage const & type is null", 0);
38123     return 0;
38124   }
38125   {
38126     try {
38127       result = (Dali::Stage *) &(arg1)->operator =((Dali::Stage const &)*arg2);
38128     } catch (std::out_of_range& e) {
38129       {
38130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38131       };
38132     } catch (std::exception& e) {
38133       {
38134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38135       };
38136     } catch (Dali::DaliException e) {
38137       {
38138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38139       };
38140     } catch (...) {
38141       {
38142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38143       };
38144     }
38145   }
38146
38147   jresult = (void *)result;
38148   return jresult;
38149 }
38150
38151
38152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Add(void * jarg1, void * jarg2) {
38153   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38154   Dali::Actor *arg2 = 0 ;
38155
38156   arg1 = (Dali::Stage *)jarg1;
38157   arg2 = (Dali::Actor *)jarg2;
38158   if (!arg2) {
38159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38160     return ;
38161   }
38162   {
38163     try {
38164       (arg1)->Add(*arg2);
38165     } catch (std::out_of_range& e) {
38166       {
38167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38168       };
38169     } catch (std::exception& e) {
38170       {
38171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38172       };
38173     } catch (Dali::DaliException e) {
38174       {
38175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38176       };
38177     } catch (...) {
38178       {
38179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38180       };
38181     }
38182   }
38183
38184 }
38185
38186
38187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_Remove(void * jarg1, void * jarg2) {
38188   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38189   Dali::Actor *arg2 = 0 ;
38190
38191   arg1 = (Dali::Stage *)jarg1;
38192   arg2 = (Dali::Actor *)jarg2;
38193   if (!arg2) {
38194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38195     return ;
38196   }
38197   {
38198     try {
38199       (arg1)->Remove(*arg2);
38200     } catch (std::out_of_range& e) {
38201       {
38202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38203       };
38204     } catch (std::exception& e) {
38205       {
38206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38207       };
38208     } catch (Dali::DaliException e) {
38209       {
38210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38211       };
38212     } catch (...) {
38213       {
38214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38215       };
38216     }
38217   }
38218
38219 }
38220
38221
38222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetSize(void * jarg1) {
38223   void * jresult ;
38224   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38225   Dali::Vector2 result;
38226
38227   arg1 = (Dali::Stage *)jarg1;
38228   {
38229     try {
38230       result = ((Dali::Stage const *)arg1)->GetSize();
38231     } catch (std::out_of_range& e) {
38232       {
38233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38234       };
38235     } catch (std::exception& e) {
38236       {
38237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38238       };
38239     } catch (Dali::DaliException e) {
38240       {
38241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38242       };
38243     } catch (...) {
38244       {
38245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38246       };
38247     }
38248   }
38249
38250   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38251   return jresult;
38252 }
38253
38254
38255 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRenderTaskList(void * jarg1) {
38256   void * jresult ;
38257   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38258   Dali::RenderTaskList result;
38259
38260   arg1 = (Dali::Stage *)jarg1;
38261   {
38262     try {
38263       result = ((Dali::Stage const *)arg1)->GetRenderTaskList();
38264     } catch (std::out_of_range& e) {
38265       {
38266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38267       };
38268     } catch (std::exception& e) {
38269       {
38270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38271       };
38272     } catch (Dali::DaliException e) {
38273       {
38274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38275       };
38276     } catch (...) {
38277       {
38278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38279       };
38280     }
38281   }
38282
38283   jresult = new Dali::RenderTaskList((const Dali::RenderTaskList &)result);
38284   return jresult;
38285 }
38286
38287
38288 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_GetLayerCount(void * jarg1) {
38289   unsigned int jresult ;
38290   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38291   unsigned int result;
38292
38293   arg1 = (Dali::Stage *)jarg1;
38294   {
38295     try {
38296       result = (unsigned int)((Dali::Stage const *)arg1)->GetLayerCount();
38297     } catch (std::out_of_range& e) {
38298       {
38299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38300       };
38301     } catch (std::exception& e) {
38302       {
38303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38304       };
38305     } catch (Dali::DaliException e) {
38306       {
38307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38308       };
38309     } catch (...) {
38310       {
38311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38312       };
38313     }
38314   }
38315
38316   jresult = result;
38317   return jresult;
38318 }
38319
38320
38321 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetLayer(void * jarg1, unsigned int jarg2) {
38322   void * jresult ;
38323   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38324   unsigned int arg2 ;
38325   Dali::Layer result;
38326
38327   arg1 = (Dali::Stage *)jarg1;
38328   arg2 = (unsigned int)jarg2;
38329   {
38330     try {
38331       result = ((Dali::Stage const *)arg1)->GetLayer(arg2);
38332     } catch (std::out_of_range& e) {
38333       {
38334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38335       };
38336     } catch (std::exception& e) {
38337       {
38338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38339       };
38340     } catch (Dali::DaliException e) {
38341       {
38342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38343       };
38344     } catch (...) {
38345       {
38346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38347       };
38348     }
38349   }
38350
38351   jresult = new Dali::Layer((const Dali::Layer &)result);
38352   return jresult;
38353 }
38354
38355
38356 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetRootLayer(void * jarg1) {
38357   void * jresult ;
38358   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38359   Dali::Layer result;
38360
38361   arg1 = (Dali::Stage *)jarg1;
38362   {
38363     try {
38364       result = ((Dali::Stage const *)arg1)->GetRootLayer();
38365     } catch (std::out_of_range& e) {
38366       {
38367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38368       };
38369     } catch (std::exception& e) {
38370       {
38371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38372       };
38373     } catch (Dali::DaliException e) {
38374       {
38375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38376       };
38377     } catch (...) {
38378       {
38379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38380       };
38381     }
38382   }
38383
38384   jresult = new Dali::Layer((const Dali::Layer &)result);
38385   return jresult;
38386 }
38387
38388
38389 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetBackgroundColor(void * jarg1, void * jarg2) {
38390   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38391   Dali::Vector4 arg2 ;
38392   Dali::Vector4 *argp2 ;
38393
38394   arg1 = (Dali::Stage *)jarg1;
38395   argp2 = (Dali::Vector4 *)jarg2;
38396   if (!argp2) {
38397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector4", 0);
38398     return ;
38399   }
38400   arg2 = *argp2;
38401   {
38402     try {
38403       (arg1)->SetBackgroundColor(arg2);
38404     } catch (std::out_of_range& e) {
38405       {
38406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38407       };
38408     } catch (std::exception& e) {
38409       {
38410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38411       };
38412     } catch (Dali::DaliException e) {
38413       {
38414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38415       };
38416     } catch (...) {
38417       {
38418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38419       };
38420     }
38421   }
38422
38423 }
38424
38425
38426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetBackgroundColor(void * jarg1) {
38427   void * jresult ;
38428   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38429   Dali::Vector4 result;
38430
38431   arg1 = (Dali::Stage *)jarg1;
38432   {
38433     try {
38434       result = ((Dali::Stage const *)arg1)->GetBackgroundColor();
38435     } catch (std::out_of_range& e) {
38436       {
38437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38438       };
38439     } catch (std::exception& e) {
38440       {
38441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38442       };
38443     } catch (Dali::DaliException e) {
38444       {
38445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38446       };
38447     } catch (...) {
38448       {
38449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38450       };
38451     }
38452   }
38453
38454   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
38455   return jresult;
38456 }
38457
38458
38459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
38460   void * jresult ;
38461   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38462   Dali::Vector2 result;
38463
38464   arg1 = (Dali::Stage *)jarg1;
38465   {
38466     try {
38467       result = ((Dali::Stage const *)arg1)->GetDpi();
38468     } catch (std::out_of_range& e) {
38469       {
38470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38471       };
38472     } catch (std::exception& e) {
38473       {
38474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38475       };
38476     } catch (Dali::DaliException e) {
38477       {
38478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38479       };
38480     } catch (...) {
38481       {
38482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38483       };
38484     }
38485   }
38486
38487   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38488   return jresult;
38489 }
38490
38491
38492 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetObjectRegistry(void * jarg1) {
38493   void * jresult ;
38494   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38495   Dali::ObjectRegistry result;
38496
38497   arg1 = (Dali::Stage *)jarg1;
38498   {
38499     try {
38500       result = ((Dali::Stage const *)arg1)->GetObjectRegistry();
38501     } catch (std::out_of_range& e) {
38502       {
38503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38504       };
38505     } catch (std::exception& e) {
38506       {
38507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38508       };
38509     } catch (Dali::DaliException e) {
38510       {
38511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38512       };
38513     } catch (...) {
38514       {
38515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38516       };
38517     }
38518   }
38519
38520   jresult = new Dali::ObjectRegistry((const Dali::ObjectRegistry &)result);
38521   return jresult;
38522 }
38523
38524
38525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38526   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38527   float arg2 ;
38528
38529   arg1 = (Dali::Stage *)jarg1;
38530   arg2 = (float)jarg2;
38531   {
38532     try {
38533       (arg1)->KeepRendering(arg2);
38534     } catch (std::out_of_range& e) {
38535       {
38536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38537       };
38538     } catch (std::exception& e) {
38539       {
38540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38541       };
38542     } catch (Dali::DaliException e) {
38543       {
38544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38545       };
38546     } catch (...) {
38547       {
38548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38549       };
38550     }
38551   }
38552
38553 }
38554
38555
38556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38557   void * jresult ;
38558   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38559   Dali::Stage::KeyEventSignalType *result = 0 ;
38560
38561   arg1 = (Dali::Stage *)jarg1;
38562   {
38563     try {
38564       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38565     } catch (std::out_of_range& e) {
38566       {
38567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38568       };
38569     } catch (std::exception& e) {
38570       {
38571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38572       };
38573     } catch (Dali::DaliException e) {
38574       {
38575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38576       };
38577     } catch (...) {
38578       {
38579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38580       };
38581     }
38582   }
38583
38584   jresult = (void *)result;
38585   return jresult;
38586 }
38587
38588
38589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38590   void * jresult ;
38591   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38592   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38593
38594   arg1 = (Dali::Stage *)jarg1;
38595   {
38596     try {
38597       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38598     } catch (std::out_of_range& e) {
38599       {
38600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38601       };
38602     } catch (std::exception& e) {
38603       {
38604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38605       };
38606     } catch (Dali::DaliException e) {
38607       {
38608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38609       };
38610     } catch (...) {
38611       {
38612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38613       };
38614     }
38615   }
38616
38617   jresult = (void *)result;
38618   return jresult;
38619 }
38620
38621
38622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38623   void * jresult ;
38624   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38625   Dali::Stage::TouchSignalType *result = 0 ;
38626
38627   arg1 = (Dali::Stage *)jarg1;
38628   {
38629     try {
38630       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38631     } catch (std::out_of_range& e) {
38632       {
38633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38634       };
38635     } catch (std::exception& e) {
38636       {
38637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38638       };
38639     } catch (Dali::DaliException e) {
38640       {
38641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38642       };
38643     } catch (...) {
38644       {
38645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38646       };
38647     }
38648   }
38649
38650   jresult = (void *)result;
38651   return jresult;
38652 }
38653
38654
38655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38656   void * jresult ;
38657   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38658   Dali::Stage::WheelEventSignalType *result = 0 ;
38659
38660   arg1 = (Dali::Stage *)jarg1;
38661   {
38662     try {
38663       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38664     } catch (std::out_of_range& e) {
38665       {
38666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38667       };
38668     } catch (std::exception& e) {
38669       {
38670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38671       };
38672     } catch (Dali::DaliException e) {
38673       {
38674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38675       };
38676     } catch (...) {
38677       {
38678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38679       };
38680     }
38681   }
38682
38683   jresult = (void *)result;
38684   return jresult;
38685 }
38686
38687
38688 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38689   void * jresult ;
38690   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38691   Dali::Stage::ContextStatusSignal *result = 0 ;
38692
38693   arg1 = (Dali::Stage *)jarg1;
38694   {
38695     try {
38696       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38697     } catch (std::out_of_range& e) {
38698       {
38699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38700       };
38701     } catch (std::exception& e) {
38702       {
38703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38704       };
38705     } catch (Dali::DaliException e) {
38706       {
38707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38708       };
38709     } catch (...) {
38710       {
38711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38712       };
38713     }
38714   }
38715
38716   jresult = (void *)result;
38717   return jresult;
38718 }
38719
38720
38721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38722   void * jresult ;
38723   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38724   Dali::Stage::ContextStatusSignal *result = 0 ;
38725
38726   arg1 = (Dali::Stage *)jarg1;
38727   {
38728     try {
38729       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38730     } catch (std::out_of_range& e) {
38731       {
38732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38733       };
38734     } catch (std::exception& e) {
38735       {
38736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38737       };
38738     } catch (Dali::DaliException e) {
38739       {
38740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38741       };
38742     } catch (...) {
38743       {
38744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38745       };
38746     }
38747   }
38748
38749   jresult = (void *)result;
38750   return jresult;
38751 }
38752
38753
38754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38755   void * jresult ;
38756   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38757   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38758
38759   arg1 = (Dali::Stage *)jarg1;
38760   {
38761     try {
38762       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38763     } catch (std::out_of_range& e) {
38764       {
38765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38766       };
38767     } catch (std::exception& e) {
38768       {
38769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38770       };
38771     } catch (Dali::DaliException e) {
38772       {
38773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38774       };
38775     } catch (...) {
38776       {
38777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38778       };
38779     }
38780   }
38781
38782   jresult = (void *)result;
38783   return jresult;
38784 }
38785
38786 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38787   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38788   Dali::DevelStage::Rendering arg2 ;
38789
38790   arg1 = (Dali::Stage *)jarg1;
38791   arg2 = (Dali::DevelStage::Rendering)jarg2;
38792   {
38793     try {
38794       DevelStage::SetRenderingBehavior(*arg1,arg2);
38795     } catch (std::out_of_range& e) {
38796       {
38797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38798       };
38799     } catch (std::exception& e) {
38800       {
38801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38802       };
38803     } catch (Dali::DaliException e) {
38804       {
38805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38806       };
38807     } catch (...) {
38808       {
38809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38810       };
38811     }
38812   }
38813
38814 }
38815
38816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38817
38818   int jresult ;
38819   int result ;
38820   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38821
38822   arg1 = (Dali::Stage *)jarg1;
38823   {
38824     try {
38825       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38826     } catch (std::out_of_range& e) {
38827       {
38828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38829       };
38830     } catch (std::exception& e) {
38831       {
38832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38833       };
38834     } catch (Dali::DaliException e) {
38835       {
38836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38837       };
38838     } catch (...) {
38839       {
38840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38841       };
38842     }
38843   }
38844
38845   jresult = result;
38846   return jresult;
38847 }
38848
38849 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38850   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38851
38852   arg1 = (Dali::RelayoutContainer *)jarg1;
38853   {
38854     try {
38855       delete arg1;
38856     } catch (std::out_of_range& e) {
38857       {
38858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38859       };
38860     } catch (std::exception& e) {
38861       {
38862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38863       };
38864     } catch (Dali::DaliException e) {
38865       {
38866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38867       };
38868     } catch (...) {
38869       {
38870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38871       };
38872     }
38873   }
38874
38875 }
38876
38877
38878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38879   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38880   Dali::Actor *arg2 = 0 ;
38881   Dali::Vector2 *arg3 = 0 ;
38882
38883   arg1 = (Dali::RelayoutContainer *)jarg1;
38884   arg2 = (Dali::Actor *)jarg2;
38885   if (!arg2) {
38886     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38887     return ;
38888   }
38889   arg3 = (Dali::Vector2 *)jarg3;
38890   if (!arg3) {
38891     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38892     return ;
38893   }
38894   {
38895     try {
38896       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38897     } catch (std::out_of_range& e) {
38898       {
38899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38900       };
38901     } catch (std::exception& e) {
38902       {
38903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38904       };
38905     } catch (Dali::DaliException e) {
38906       {
38907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38908       };
38909     } catch (...) {
38910       {
38911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38912       };
38913     }
38914   }
38915
38916 }
38917
38918
38919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38920   void * jresult ;
38921   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38922   Dali::CustomActor result;
38923
38924   arg1 = (Dali::CustomActorImpl *)jarg1;
38925   {
38926     try {
38927       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38928     } catch (std::out_of_range& e) {
38929       {
38930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38931       };
38932     } catch (std::exception& e) {
38933       {
38934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38935       };
38936     } catch (Dali::DaliException e) {
38937       {
38938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38939       };
38940     } catch (...) {
38941       {
38942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38943       };
38944     }
38945   }
38946
38947   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38948   return jresult;
38949 }
38950
38951
38952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
38953   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38954   int arg2 ;
38955
38956   arg1 = (Dali::CustomActorImpl *)jarg1;
38957   arg2 = (int)jarg2;
38958   {
38959     try {
38960       (arg1)->OnStageConnection(arg2);
38961     } catch (std::out_of_range& e) {
38962       {
38963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38964       };
38965     } catch (std::exception& e) {
38966       {
38967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38968       };
38969     } catch (Dali::DaliException e) {
38970       {
38971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38972       };
38973     } catch (...) {
38974       {
38975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38976       };
38977     }
38978   }
38979
38980 }
38981
38982
38983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
38984   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38985
38986   arg1 = (Dali::CustomActorImpl *)jarg1;
38987   {
38988     try {
38989       (arg1)->OnStageDisconnection();
38990     } catch (std::out_of_range& e) {
38991       {
38992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38993       };
38994     } catch (std::exception& e) {
38995       {
38996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38997       };
38998     } catch (Dali::DaliException e) {
38999       {
39000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39001       };
39002     } catch (...) {
39003       {
39004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39005       };
39006     }
39007   }
39008
39009 }
39010
39011
39012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
39013   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39014   Dali::Actor *arg2 = 0 ;
39015
39016   arg1 = (Dali::CustomActorImpl *)jarg1;
39017   arg2 = (Dali::Actor *)jarg2;
39018   if (!arg2) {
39019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39020     return ;
39021   }
39022   {
39023     try {
39024       (arg1)->OnChildAdd(*arg2);
39025     } catch (std::out_of_range& e) {
39026       {
39027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39028       };
39029     } catch (std::exception& e) {
39030       {
39031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39032       };
39033     } catch (Dali::DaliException e) {
39034       {
39035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39036       };
39037     } catch (...) {
39038       {
39039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39040       };
39041     }
39042   }
39043
39044 }
39045
39046
39047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
39048   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39049   Dali::Actor *arg2 = 0 ;
39050
39051   arg1 = (Dali::CustomActorImpl *)jarg1;
39052   arg2 = (Dali::Actor *)jarg2;
39053   if (!arg2) {
39054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
39055     return ;
39056   }
39057   {
39058     try {
39059       (arg1)->OnChildRemove(*arg2);
39060     } catch (std::out_of_range& e) {
39061       {
39062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39063       };
39064     } catch (std::exception& e) {
39065       {
39066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39067       };
39068     } catch (Dali::DaliException e) {
39069       {
39070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39071       };
39072     } catch (...) {
39073       {
39074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39075       };
39076     }
39077   }
39078
39079 }
39080
39081
39082 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
39083   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39084   Dali::Property::Index arg2 ;
39085   Dali::Property::Value arg3 ;
39086   Dali::Property::Value *argp3 ;
39087
39088   arg1 = (Dali::CustomActorImpl *)jarg1;
39089   arg2 = (Dali::Property::Index)jarg2;
39090   argp3 = (Dali::Property::Value *)jarg3;
39091   if (!argp3) {
39092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
39093     return ;
39094   }
39095   arg3 = *argp3;
39096   {
39097     try {
39098       (arg1)->OnPropertySet(arg2,arg3);
39099     } catch (std::out_of_range& e) {
39100       {
39101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39102       };
39103     } catch (std::exception& e) {
39104       {
39105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39106       };
39107     } catch (Dali::DaliException e) {
39108       {
39109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39110       };
39111     } catch (...) {
39112       {
39113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39114       };
39115     }
39116   }
39117
39118 }
39119
39120
39121 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
39122   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39123   Dali::Vector3 *arg2 = 0 ;
39124
39125   arg1 = (Dali::CustomActorImpl *)jarg1;
39126   arg2 = (Dali::Vector3 *)jarg2;
39127   if (!arg2) {
39128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39129     return ;
39130   }
39131   {
39132     try {
39133       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
39134     } catch (std::out_of_range& e) {
39135       {
39136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39137       };
39138     } catch (std::exception& e) {
39139       {
39140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39141       };
39142     } catch (Dali::DaliException e) {
39143       {
39144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39145       };
39146     } catch (...) {
39147       {
39148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39149       };
39150     }
39151   }
39152
39153 }
39154
39155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
39156   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39157   Dali::Animation *arg2 = 0 ;
39158   Dali::Vector3 *arg3 = 0 ;
39159
39160   arg1 = (Dali::CustomActorImpl *)jarg1;
39161   arg2 = (Dali::Animation *)jarg2;
39162   if (!arg2) {
39163     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
39164     return ;
39165   }
39166   arg3 = (Dali::Vector3 *)jarg3;
39167   if (!arg3) {
39168     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
39169     return ;
39170   }
39171   {
39172     try {
39173       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
39174     } catch (std::out_of_range& e) {
39175       {
39176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39177       };
39178     } catch (std::exception& e) {
39179       {
39180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39181       };
39182     } catch (Dali::DaliException e) {
39183       {
39184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39185       };
39186     } catch (...) {
39187       {
39188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39189       };
39190     }
39191   }
39192
39193 }
39194
39195
39196 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
39197   unsigned int jresult ;
39198   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39199   Dali::TouchEvent *arg2 = 0 ;
39200   bool result;
39201
39202   arg1 = (Dali::CustomActorImpl *)jarg1;
39203   arg2 = (Dali::TouchEvent *)jarg2;
39204   if (!arg2) {
39205     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
39206     return 0;
39207   }
39208   {
39209     try {
39210       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
39211     } catch (std::out_of_range& e) {
39212       {
39213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39214       };
39215     } catch (std::exception& e) {
39216       {
39217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (Dali::DaliException e) {
39220       {
39221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39222       };
39223     } catch (...) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39226       };
39227     }
39228   }
39229
39230   jresult = result;
39231   return jresult;
39232 }
39233
39234
39235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
39236   unsigned int jresult ;
39237   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39238   Dali::HoverEvent *arg2 = 0 ;
39239   bool result;
39240
39241   arg1 = (Dali::CustomActorImpl *)jarg1;
39242   arg2 = (Dali::HoverEvent *)jarg2;
39243   if (!arg2) {
39244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
39245     return 0;
39246   }
39247   {
39248     try {
39249       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
39250     } catch (std::out_of_range& e) {
39251       {
39252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39253       };
39254     } catch (std::exception& e) {
39255       {
39256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39257       };
39258     } catch (Dali::DaliException e) {
39259       {
39260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39261       };
39262     } catch (...) {
39263       {
39264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39265       };
39266     }
39267   }
39268
39269   jresult = result;
39270   return jresult;
39271 }
39272
39273
39274 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
39275   unsigned int jresult ;
39276   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39277   Dali::KeyEvent *arg2 = 0 ;
39278   bool result;
39279
39280   arg1 = (Dali::CustomActorImpl *)jarg1;
39281   arg2 = (Dali::KeyEvent *)jarg2;
39282   if (!arg2) {
39283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
39284     return 0;
39285   }
39286   {
39287     try {
39288       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
39289     } catch (std::out_of_range& e) {
39290       {
39291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39292       };
39293     } catch (std::exception& e) {
39294       {
39295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39296       };
39297     } catch (Dali::DaliException e) {
39298       {
39299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39300       };
39301     } catch (...) {
39302       {
39303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39304       };
39305     }
39306   }
39307
39308   jresult = result;
39309   return jresult;
39310 }
39311
39312
39313 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
39314   unsigned int jresult ;
39315   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39316   Dali::WheelEvent *arg2 = 0 ;
39317   bool result;
39318
39319   arg1 = (Dali::CustomActorImpl *)jarg1;
39320   arg2 = (Dali::WheelEvent *)jarg2;
39321   if (!arg2) {
39322     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
39323     return 0;
39324   }
39325   {
39326     try {
39327       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
39328     } catch (std::out_of_range& e) {
39329       {
39330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39331       };
39332     } catch (std::exception& e) {
39333       {
39334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39335       };
39336     } catch (Dali::DaliException e) {
39337       {
39338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39339       };
39340     } catch (...) {
39341       {
39342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39343       };
39344     }
39345   }
39346
39347   jresult = result;
39348   return jresult;
39349 }
39350
39351
39352 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
39353   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39354   Dali::Vector2 *arg2 = 0 ;
39355   Dali::RelayoutContainer *arg3 = 0 ;
39356
39357   arg1 = (Dali::CustomActorImpl *)jarg1;
39358   arg2 = (Dali::Vector2 *)jarg2;
39359   if (!arg2) {
39360     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
39361     return ;
39362   }
39363   arg3 = (Dali::RelayoutContainer *)jarg3;
39364   if (!arg3) {
39365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
39366     return ;
39367   }
39368   {
39369     try {
39370       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
39371     } catch (std::out_of_range& e) {
39372       {
39373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39374       };
39375     } catch (std::exception& e) {
39376       {
39377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39378       };
39379     } catch (Dali::DaliException e) {
39380       {
39381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39382       };
39383     } catch (...) {
39384       {
39385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39386       };
39387     }
39388   }
39389
39390 }
39391
39392
39393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
39394   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39395   Dali::ResizePolicy::Type arg2 ;
39396   Dali::Dimension::Type arg3 ;
39397
39398   arg1 = (Dali::CustomActorImpl *)jarg1;
39399   arg2 = (Dali::ResizePolicy::Type)jarg2;
39400   arg3 = (Dali::Dimension::Type)jarg3;
39401   {
39402     try {
39403       (arg1)->OnSetResizePolicy(arg2,arg3);
39404     } catch (std::out_of_range& e) {
39405       {
39406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39407       };
39408     } catch (std::exception& e) {
39409       {
39410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39411       };
39412     } catch (Dali::DaliException e) {
39413       {
39414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39415       };
39416     } catch (...) {
39417       {
39418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39419       };
39420     }
39421   }
39422
39423 }
39424
39425
39426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
39427   void * jresult ;
39428   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39429   Dali::Vector3 result;
39430
39431   arg1 = (Dali::CustomActorImpl *)jarg1;
39432   {
39433     try {
39434       result = (arg1)->GetNaturalSize();
39435     } catch (std::out_of_range& e) {
39436       {
39437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39438       };
39439     } catch (std::exception& e) {
39440       {
39441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39442       };
39443     } catch (Dali::DaliException e) {
39444       {
39445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39446       };
39447     } catch (...) {
39448       {
39449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39450       };
39451     }
39452   }
39453
39454   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
39455   return jresult;
39456 }
39457
39458
39459 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
39460   float jresult ;
39461   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39462   Dali::Actor *arg2 = 0 ;
39463   Dali::Dimension::Type arg3 ;
39464   float result;
39465
39466   arg1 = (Dali::CustomActorImpl *)jarg1;
39467   arg2 = (Dali::Actor *)jarg2;
39468   if (!arg2) {
39469     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
39470     return 0;
39471   }
39472   arg3 = (Dali::Dimension::Type)jarg3;
39473   {
39474     try {
39475       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
39476     } catch (std::out_of_range& e) {
39477       {
39478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39479       };
39480     } catch (std::exception& e) {
39481       {
39482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39483       };
39484     } catch (Dali::DaliException e) {
39485       {
39486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39487       };
39488     } catch (...) {
39489       {
39490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39491       };
39492     }
39493   }
39494
39495   jresult = result;
39496   return jresult;
39497 }
39498
39499
39500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39501   float jresult ;
39502   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39503   float arg2 ;
39504   float result;
39505
39506   arg1 = (Dali::CustomActorImpl *)jarg1;
39507   arg2 = (float)jarg2;
39508   {
39509     try {
39510       result = (float)(arg1)->GetHeightForWidth(arg2);
39511     } catch (std::out_of_range& e) {
39512       {
39513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39514       };
39515     } catch (std::exception& e) {
39516       {
39517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39518       };
39519     } catch (Dali::DaliException e) {
39520       {
39521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39522       };
39523     } catch (...) {
39524       {
39525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39526       };
39527     }
39528   }
39529
39530   jresult = result;
39531   return jresult;
39532 }
39533
39534
39535 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39536   float jresult ;
39537   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39538   float arg2 ;
39539   float result;
39540
39541   arg1 = (Dali::CustomActorImpl *)jarg1;
39542   arg2 = (float)jarg2;
39543   {
39544     try {
39545       result = (float)(arg1)->GetWidthForHeight(arg2);
39546     } catch (std::out_of_range& e) {
39547       {
39548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39549       };
39550     } catch (std::exception& e) {
39551       {
39552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39553       };
39554     } catch (Dali::DaliException e) {
39555       {
39556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39557       };
39558     } catch (...) {
39559       {
39560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39561       };
39562     }
39563   }
39564
39565   jresult = result;
39566   return jresult;
39567 }
39568
39569
39570 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39571   unsigned int jresult ;
39572   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39573   Dali::Dimension::Type arg2 ;
39574   bool result;
39575
39576   arg1 = (Dali::CustomActorImpl *)jarg1;
39577   arg2 = (Dali::Dimension::Type)jarg2;
39578   {
39579     try {
39580       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39581     } catch (std::out_of_range& e) {
39582       {
39583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39584       };
39585     } catch (std::exception& e) {
39586       {
39587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39588       };
39589     } catch (Dali::DaliException e) {
39590       {
39591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39592       };
39593     } catch (...) {
39594       {
39595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39596       };
39597     }
39598   }
39599
39600   jresult = result;
39601   return jresult;
39602 }
39603
39604
39605 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39606   unsigned int jresult ;
39607   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39608   bool result;
39609
39610   arg1 = (Dali::CustomActorImpl *)jarg1;
39611   {
39612     try {
39613       result = (bool)(arg1)->RelayoutDependentOnChildren();
39614     } catch (std::out_of_range& e) {
39615       {
39616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39617       };
39618     } catch (std::exception& e) {
39619       {
39620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39621       };
39622     } catch (Dali::DaliException e) {
39623       {
39624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39625       };
39626     } catch (...) {
39627       {
39628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39629       };
39630     }
39631   }
39632
39633   jresult = result;
39634   return jresult;
39635 }
39636
39637
39638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39639   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39640   Dali::Dimension::Type arg2 ;
39641
39642   arg1 = (Dali::CustomActorImpl *)jarg1;
39643   arg2 = (Dali::Dimension::Type)jarg2;
39644   {
39645     try {
39646       (arg1)->OnCalculateRelayoutSize(arg2);
39647     } catch (std::out_of_range& e) {
39648       {
39649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39650       };
39651     } catch (std::exception& e) {
39652       {
39653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39654       };
39655     } catch (Dali::DaliException e) {
39656       {
39657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39658       };
39659     } catch (...) {
39660       {
39661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39662       };
39663     }
39664   }
39665
39666 }
39667
39668
39669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39670   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39671   float arg2 ;
39672   Dali::Dimension::Type arg3 ;
39673
39674   arg1 = (Dali::CustomActorImpl *)jarg1;
39675   arg2 = (float)jarg2;
39676   arg3 = (Dali::Dimension::Type)jarg3;
39677   {
39678     try {
39679       (arg1)->OnLayoutNegotiated(arg2,arg3);
39680     } catch (std::out_of_range& e) {
39681       {
39682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39683       };
39684     } catch (std::exception& e) {
39685       {
39686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39687       };
39688     } catch (Dali::DaliException e) {
39689       {
39690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39691       };
39692     } catch (...) {
39693       {
39694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39695       };
39696     }
39697   }
39698
39699 }
39700
39701
39702 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39703   unsigned int jresult ;
39704   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39705   bool result;
39706
39707   arg1 = (Dali::CustomActorImpl *)jarg1;
39708   {
39709     try {
39710       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39711     } catch (std::out_of_range& e) {
39712       {
39713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39714       };
39715     } catch (std::exception& e) {
39716       {
39717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39718       };
39719     } catch (Dali::DaliException e) {
39720       {
39721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39722       };
39723     } catch (...) {
39724       {
39725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39726       };
39727     }
39728   }
39729
39730   jresult = result;
39731   return jresult;
39732 }
39733
39734
39735 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39736   unsigned int jresult ;
39737   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39738   bool result;
39739
39740   arg1 = (Dali::CustomActorImpl *)jarg1;
39741   {
39742     try {
39743       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39744     } catch (std::out_of_range& e) {
39745       {
39746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39747       };
39748     } catch (std::exception& e) {
39749       {
39750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39751       };
39752     } catch (Dali::DaliException e) {
39753       {
39754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39755       };
39756     } catch (...) {
39757       {
39758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39759       };
39760     }
39761   }
39762
39763   jresult = result;
39764   return jresult;
39765 }
39766
39767
39768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39769   unsigned int jresult ;
39770   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39771   bool result;
39772
39773   arg1 = (Dali::CustomActorImpl *)jarg1;
39774   {
39775     try {
39776       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39777     } catch (std::out_of_range& e) {
39778       {
39779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39780       };
39781     } catch (std::exception& e) {
39782       {
39783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39784       };
39785     } catch (Dali::DaliException e) {
39786       {
39787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39788       };
39789     } catch (...) {
39790       {
39791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39792       };
39793     }
39794   }
39795
39796   jresult = result;
39797   return jresult;
39798 }
39799
39800
39801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39802   unsigned int jresult ;
39803   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39804   bool result;
39805
39806   arg1 = (Dali::CustomActorImpl *)jarg1;
39807   {
39808     try {
39809       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39810     } catch (std::out_of_range& e) {
39811       {
39812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39813       };
39814     } catch (std::exception& e) {
39815       {
39816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39817       };
39818     } catch (Dali::DaliException e) {
39819       {
39820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39821       };
39822     } catch (...) {
39823       {
39824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39825       };
39826     }
39827   }
39828
39829   jresult = result;
39830   return jresult;
39831 }
39832
39833
39834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39835   void * jresult ;
39836   Dali::CustomActor *result = 0 ;
39837
39838   {
39839     try {
39840       result = (Dali::CustomActor *)new Dali::CustomActor();
39841     } catch (std::out_of_range& e) {
39842       {
39843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39844       };
39845     } catch (std::exception& e) {
39846       {
39847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39848       };
39849     } catch (Dali::DaliException e) {
39850       {
39851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39852       };
39853     } catch (...) {
39854       {
39855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39856       };
39857     }
39858   }
39859
39860   jresult = (void *)result;
39861   return jresult;
39862 }
39863
39864
39865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39866   void * jresult ;
39867   Dali::BaseHandle arg1 ;
39868   Dali::BaseHandle *argp1 ;
39869   Dali::CustomActor result;
39870
39871   argp1 = (Dali::BaseHandle *)jarg1;
39872   if (!argp1) {
39873     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39874     return 0;
39875   }
39876   arg1 = *argp1;
39877   {
39878     try {
39879       result = Dali::CustomActor::DownCast(arg1);
39880     } catch (std::out_of_range& e) {
39881       {
39882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39883       };
39884     } catch (std::exception& e) {
39885       {
39886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39887       };
39888     } catch (Dali::DaliException e) {
39889       {
39890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39891       };
39892     } catch (...) {
39893       {
39894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39895       };
39896     }
39897   }
39898
39899   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39900   return jresult;
39901 }
39902
39903
39904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39905   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39906
39907   arg1 = (Dali::CustomActor *)jarg1;
39908   {
39909     try {
39910       delete arg1;
39911     } catch (std::out_of_range& e) {
39912       {
39913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39914       };
39915     } catch (std::exception& e) {
39916       {
39917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39918       };
39919     } catch (Dali::DaliException e) {
39920       {
39921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39922       };
39923     } catch (...) {
39924       {
39925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39926       };
39927     }
39928   }
39929
39930 }
39931
39932
39933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39934   void * jresult ;
39935   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39936   Dali::CustomActorImpl *result = 0 ;
39937
39938   arg1 = (Dali::CustomActor *)jarg1;
39939   {
39940     try {
39941       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39942     } catch (std::out_of_range& e) {
39943       {
39944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39945       };
39946     } catch (std::exception& e) {
39947       {
39948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39949       };
39950     } catch (Dali::DaliException e) {
39951       {
39952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39953       };
39954     } catch (...) {
39955       {
39956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39957       };
39958     }
39959   }
39960
39961   jresult = (void *)result;
39962   return jresult;
39963 }
39964
39965
39966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39967   void * jresult ;
39968   Dali::CustomActorImpl *arg1 = 0 ;
39969   Dali::CustomActor *result = 0 ;
39970
39971   arg1 = (Dali::CustomActorImpl *)jarg1;
39972   if (!arg1) {
39973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39974     return 0;
39975   }
39976   {
39977     try {
39978       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39979     } catch (std::out_of_range& e) {
39980       {
39981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39982       };
39983     } catch (std::exception& e) {
39984       {
39985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39986       };
39987     } catch (Dali::DaliException e) {
39988       {
39989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39990       };
39991     } catch (...) {
39992       {
39993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39994       };
39995     }
39996   }
39997
39998   jresult = (void *)result;
39999   return jresult;
40000 }
40001
40002
40003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
40004   void * jresult ;
40005   Dali::CustomActor *arg1 = 0 ;
40006   Dali::CustomActor *result = 0 ;
40007
40008   arg1 = (Dali::CustomActor *)jarg1;
40009   if (!arg1) {
40010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40011     return 0;
40012   }
40013   {
40014     try {
40015       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
40016     } catch (std::out_of_range& e) {
40017       {
40018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40019       };
40020     } catch (std::exception& e) {
40021       {
40022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40023       };
40024     } catch (Dali::DaliException e) {
40025       {
40026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40027       };
40028     } catch (...) {
40029       {
40030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40031       };
40032     }
40033   }
40034
40035   jresult = (void *)result;
40036   return jresult;
40037 }
40038
40039
40040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
40041   void * jresult ;
40042   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
40043   Dali::CustomActor *arg2 = 0 ;
40044   Dali::CustomActor *result = 0 ;
40045
40046   arg1 = (Dali::CustomActor *)jarg1;
40047   arg2 = (Dali::CustomActor *)jarg2;
40048   if (!arg2) {
40049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
40050     return 0;
40051   }
40052   {
40053     try {
40054       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
40055     } catch (std::out_of_range& e) {
40056       {
40057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40058       };
40059     } catch (std::exception& e) {
40060       {
40061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40062       };
40063     } catch (Dali::DaliException e) {
40064       {
40065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40066       };
40067     } catch (...) {
40068       {
40069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40070       };
40071     }
40072   }
40073
40074   jresult = (void *)result;
40075   return jresult;
40076 }
40077
40078
40079 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
40080   int jresult ;
40081   int result;
40082
40083   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
40084   jresult = (int)result;
40085   return jresult;
40086 }
40087
40088
40089 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
40090   int jresult ;
40091   int result;
40092
40093   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
40094   jresult = (int)result;
40095   return jresult;
40096 }
40097
40098
40099 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
40100   int jresult ;
40101   int result;
40102
40103   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
40104   jresult = (int)result;
40105   return jresult;
40106 }
40107
40108
40109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
40110   int jresult ;
40111   int result;
40112
40113   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
40114   jresult = (int)result;
40115   return jresult;
40116 }
40117
40118
40119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
40120   int jresult ;
40121   int result;
40122
40123   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
40124   jresult = (int)result;
40125   return jresult;
40126 }
40127
40128
40129 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
40130   int jresult ;
40131   int result;
40132
40133   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
40134   jresult = (int)result;
40135   return jresult;
40136 }
40137
40138
40139 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
40140   int jresult ;
40141   int result;
40142
40143   result = (int)Dali::PanGestureDetector::Property::PANNING;
40144   jresult = (int)result;
40145   return jresult;
40146 }
40147
40148
40149 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
40150   void * jresult ;
40151   Dali::PanGestureDetector::Property *result = 0 ;
40152
40153   {
40154     try {
40155       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
40156     } catch (std::out_of_range& e) {
40157       {
40158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40159       };
40160     } catch (std::exception& e) {
40161       {
40162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40163       };
40164     } catch (Dali::DaliException e) {
40165       {
40166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40167       };
40168     } catch (...) {
40169       {
40170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40171       };
40172     }
40173   }
40174
40175   jresult = (void *)result;
40176   return jresult;
40177 }
40178
40179
40180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
40181   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
40182
40183   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
40184   {
40185     try {
40186       delete arg1;
40187     } catch (std::out_of_range& e) {
40188       {
40189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40190       };
40191     } catch (std::exception& e) {
40192       {
40193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40194       };
40195     } catch (Dali::DaliException e) {
40196       {
40197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40198       };
40199     } catch (...) {
40200       {
40201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40202       };
40203     }
40204   }
40205
40206 }
40207
40208
40209 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
40210   void * jresult ;
40211   Dali::Radian *result = 0 ;
40212
40213   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
40214   jresult = (void *)result;
40215   return jresult;
40216 }
40217
40218
40219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
40220   void * jresult ;
40221   Dali::Radian *result = 0 ;
40222
40223   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
40224   jresult = (void *)result;
40225   return jresult;
40226 }
40227
40228
40229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
40230   void * jresult ;
40231   Dali::Radian *result = 0 ;
40232
40233   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
40234   jresult = (void *)result;
40235   return jresult;
40236 }
40237
40238
40239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
40240   void * jresult ;
40241   Dali::Radian *result = 0 ;
40242
40243   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
40244   jresult = (void *)result;
40245   return jresult;
40246 }
40247
40248
40249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
40250   void * jresult ;
40251   Dali::Radian *result = 0 ;
40252
40253   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
40254   jresult = (void *)result;
40255   return jresult;
40256 }
40257
40258
40259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
40260   void * jresult ;
40261   Dali::Radian *result = 0 ;
40262
40263   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
40264   jresult = (void *)result;
40265   return jresult;
40266 }
40267
40268
40269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
40270   void * jresult ;
40271   Dali::Radian *result = 0 ;
40272
40273   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
40274   jresult = (void *)result;
40275   return jresult;
40276 }
40277
40278
40279 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
40280   void * jresult ;
40281   Dali::PanGestureDetector *result = 0 ;
40282
40283   {
40284     try {
40285       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
40286     } catch (std::out_of_range& e) {
40287       {
40288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40289       };
40290     } catch (std::exception& e) {
40291       {
40292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40293       };
40294     } catch (Dali::DaliException e) {
40295       {
40296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40297       };
40298     } catch (...) {
40299       {
40300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40301       };
40302     }
40303   }
40304
40305   jresult = (void *)result;
40306   return jresult;
40307 }
40308
40309
40310 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
40311   void * jresult ;
40312   Dali::PanGestureDetector result;
40313
40314   {
40315     try {
40316       result = Dali::PanGestureDetector::New();
40317     } catch (std::out_of_range& e) {
40318       {
40319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40320       };
40321     } catch (std::exception& e) {
40322       {
40323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40324       };
40325     } catch (Dali::DaliException e) {
40326       {
40327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40328       };
40329     } catch (...) {
40330       {
40331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40332       };
40333     }
40334   }
40335
40336   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40337   return jresult;
40338 }
40339
40340
40341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
40342   void * jresult ;
40343   Dali::BaseHandle arg1 ;
40344   Dali::BaseHandle *argp1 ;
40345   Dali::PanGestureDetector result;
40346
40347   argp1 = (Dali::BaseHandle *)jarg1;
40348   if (!argp1) {
40349     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
40350     return 0;
40351   }
40352   arg1 = *argp1;
40353   {
40354     try {
40355       result = Dali::PanGestureDetector::DownCast(arg1);
40356     } catch (std::out_of_range& e) {
40357       {
40358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40359       };
40360     } catch (std::exception& e) {
40361       {
40362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40363       };
40364     } catch (Dali::DaliException e) {
40365       {
40366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40367       };
40368     } catch (...) {
40369       {
40370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40371       };
40372     }
40373   }
40374
40375   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
40376   return jresult;
40377 }
40378
40379
40380 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
40381   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40382
40383   arg1 = (Dali::PanGestureDetector *)jarg1;
40384   {
40385     try {
40386       delete arg1;
40387     } catch (std::out_of_range& e) {
40388       {
40389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40390       };
40391     } catch (std::exception& e) {
40392       {
40393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40394       };
40395     } catch (Dali::DaliException e) {
40396       {
40397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40398       };
40399     } catch (...) {
40400       {
40401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40402       };
40403     }
40404   }
40405
40406 }
40407
40408
40409 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
40410   void * jresult ;
40411   Dali::PanGestureDetector *arg1 = 0 ;
40412   Dali::PanGestureDetector *result = 0 ;
40413
40414   arg1 = (Dali::PanGestureDetector *)jarg1;
40415   if (!arg1) {
40416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40417     return 0;
40418   }
40419   {
40420     try {
40421       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
40422     } catch (std::out_of_range& e) {
40423       {
40424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40425       };
40426     } catch (std::exception& e) {
40427       {
40428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40429       };
40430     } catch (Dali::DaliException e) {
40431       {
40432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40433       };
40434     } catch (...) {
40435       {
40436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40437       };
40438     }
40439   }
40440
40441   jresult = (void *)result;
40442   return jresult;
40443 }
40444
40445
40446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
40447   void * jresult ;
40448   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40449   Dali::PanGestureDetector *arg2 = 0 ;
40450   Dali::PanGestureDetector *result = 0 ;
40451
40452   arg1 = (Dali::PanGestureDetector *)jarg1;
40453   arg2 = (Dali::PanGestureDetector *)jarg2;
40454   if (!arg2) {
40455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
40456     return 0;
40457   }
40458   {
40459     try {
40460       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
40461     } catch (std::out_of_range& e) {
40462       {
40463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40464       };
40465     } catch (std::exception& e) {
40466       {
40467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40468       };
40469     } catch (Dali::DaliException e) {
40470       {
40471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40472       };
40473     } catch (...) {
40474       {
40475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40476       };
40477     }
40478   }
40479
40480   jresult = (void *)result;
40481   return jresult;
40482 }
40483
40484
40485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
40486   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40487   unsigned int arg2 ;
40488
40489   arg1 = (Dali::PanGestureDetector *)jarg1;
40490   arg2 = (unsigned int)jarg2;
40491   {
40492     try {
40493       (arg1)->SetMinimumTouchesRequired(arg2);
40494     } catch (std::out_of_range& e) {
40495       {
40496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40497       };
40498     } catch (std::exception& e) {
40499       {
40500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40501       };
40502     } catch (Dali::DaliException e) {
40503       {
40504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40505       };
40506     } catch (...) {
40507       {
40508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40509       };
40510     }
40511   }
40512
40513 }
40514
40515
40516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40517   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40518   unsigned int arg2 ;
40519
40520   arg1 = (Dali::PanGestureDetector *)jarg1;
40521   arg2 = (unsigned int)jarg2;
40522   {
40523     try {
40524       (arg1)->SetMaximumTouchesRequired(arg2);
40525     } catch (std::out_of_range& e) {
40526       {
40527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40528       };
40529     } catch (std::exception& e) {
40530       {
40531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40532       };
40533     } catch (Dali::DaliException e) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40540       };
40541     }
40542   }
40543
40544 }
40545
40546
40547 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40548   unsigned int jresult ;
40549   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40550   unsigned int result;
40551
40552   arg1 = (Dali::PanGestureDetector *)jarg1;
40553   {
40554     try {
40555       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40556     } catch (std::out_of_range& e) {
40557       {
40558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40559       };
40560     } catch (std::exception& e) {
40561       {
40562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40563       };
40564     } catch (Dali::DaliException e) {
40565       {
40566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40567       };
40568     } catch (...) {
40569       {
40570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40571       };
40572     }
40573   }
40574
40575   jresult = result;
40576   return jresult;
40577 }
40578
40579
40580 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40581   unsigned int jresult ;
40582   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40583   unsigned int result;
40584
40585   arg1 = (Dali::PanGestureDetector *)jarg1;
40586   {
40587     try {
40588       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40589     } catch (std::out_of_range& e) {
40590       {
40591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40592       };
40593     } catch (std::exception& e) {
40594       {
40595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40596       };
40597     } catch (Dali::DaliException e) {
40598       {
40599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40600       };
40601     } catch (...) {
40602       {
40603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40604       };
40605     }
40606   }
40607
40608   jresult = result;
40609   return jresult;
40610 }
40611
40612
40613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40614   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40615   Dali::Radian arg2 ;
40616   Dali::Radian arg3 ;
40617   Dali::Radian *argp2 ;
40618   Dali::Radian *argp3 ;
40619
40620   arg1 = (Dali::PanGestureDetector *)jarg1;
40621   argp2 = (Dali::Radian *)jarg2;
40622   if (!argp2) {
40623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40624     return ;
40625   }
40626   arg2 = *argp2;
40627   argp3 = (Dali::Radian *)jarg3;
40628   if (!argp3) {
40629     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40630     return ;
40631   }
40632   arg3 = *argp3;
40633   {
40634     try {
40635       (arg1)->AddAngle(arg2,arg3);
40636     } catch (std::out_of_range& e) {
40637       {
40638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40639       };
40640     } catch (std::exception& e) {
40641       {
40642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40643       };
40644     } catch (Dali::DaliException e) {
40645       {
40646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40647       };
40648     } catch (...) {
40649       {
40650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40651       };
40652     }
40653   }
40654
40655 }
40656
40657
40658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40659   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40660   Dali::Radian arg2 ;
40661   Dali::Radian *argp2 ;
40662
40663   arg1 = (Dali::PanGestureDetector *)jarg1;
40664   argp2 = (Dali::Radian *)jarg2;
40665   if (!argp2) {
40666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40667     return ;
40668   }
40669   arg2 = *argp2;
40670   {
40671     try {
40672       (arg1)->AddAngle(arg2);
40673     } catch (std::out_of_range& e) {
40674       {
40675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40676       };
40677     } catch (std::exception& e) {
40678       {
40679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40680       };
40681     } catch (Dali::DaliException e) {
40682       {
40683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40684       };
40685     } catch (...) {
40686       {
40687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40688       };
40689     }
40690   }
40691
40692 }
40693
40694
40695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40696   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40697   Dali::Radian arg2 ;
40698   Dali::Radian arg3 ;
40699   Dali::Radian *argp2 ;
40700   Dali::Radian *argp3 ;
40701
40702   arg1 = (Dali::PanGestureDetector *)jarg1;
40703   argp2 = (Dali::Radian *)jarg2;
40704   if (!argp2) {
40705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40706     return ;
40707   }
40708   arg2 = *argp2;
40709   argp3 = (Dali::Radian *)jarg3;
40710   if (!argp3) {
40711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40712     return ;
40713   }
40714   arg3 = *argp3;
40715   {
40716     try {
40717       (arg1)->AddDirection(arg2,arg3);
40718     } catch (std::out_of_range& e) {
40719       {
40720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40721       };
40722     } catch (std::exception& e) {
40723       {
40724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40725       };
40726     } catch (Dali::DaliException e) {
40727       {
40728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40729       };
40730     } catch (...) {
40731       {
40732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40733       };
40734     }
40735   }
40736
40737 }
40738
40739
40740 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40741   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40742   Dali::Radian arg2 ;
40743   Dali::Radian *argp2 ;
40744
40745   arg1 = (Dali::PanGestureDetector *)jarg1;
40746   argp2 = (Dali::Radian *)jarg2;
40747   if (!argp2) {
40748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40749     return ;
40750   }
40751   arg2 = *argp2;
40752   {
40753     try {
40754       (arg1)->AddDirection(arg2);
40755     } catch (std::out_of_range& e) {
40756       {
40757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40758       };
40759     } catch (std::exception& e) {
40760       {
40761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40762       };
40763     } catch (Dali::DaliException e) {
40764       {
40765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40766       };
40767     } catch (...) {
40768       {
40769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40770       };
40771     }
40772   }
40773
40774 }
40775
40776
40777 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40778   unsigned long jresult ;
40779   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40780   size_t result;
40781
40782   arg1 = (Dali::PanGestureDetector *)jarg1;
40783   {
40784     try {
40785       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40786     } catch (std::out_of_range& e) {
40787       {
40788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40789       };
40790     } catch (std::exception& e) {
40791       {
40792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40793       };
40794     } catch (Dali::DaliException e) {
40795       {
40796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40797       };
40798     } catch (...) {
40799       {
40800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40801       };
40802     }
40803   }
40804
40805   jresult = (unsigned long)result;
40806   return jresult;
40807 }
40808
40809
40810 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40811   void * jresult ;
40812   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40813   size_t arg2 ;
40814   Dali::PanGestureDetector::AngleThresholdPair result;
40815
40816   arg1 = (Dali::PanGestureDetector *)jarg1;
40817   arg2 = (size_t)jarg2;
40818   {
40819     try {
40820       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40821     } catch (std::out_of_range& e) {
40822       {
40823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40824       };
40825     } catch (std::exception& e) {
40826       {
40827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40828       };
40829     } catch (Dali::DaliException e) {
40830       {
40831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40832       };
40833     } catch (...) {
40834       {
40835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40836       };
40837     }
40838   }
40839
40840   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40841   return jresult;
40842 }
40843
40844
40845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40846   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40847
40848   arg1 = (Dali::PanGestureDetector *)jarg1;
40849   {
40850     try {
40851       (arg1)->ClearAngles();
40852     } catch (std::out_of_range& e) {
40853       {
40854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40855       };
40856     } catch (std::exception& e) {
40857       {
40858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40859       };
40860     } catch (Dali::DaliException e) {
40861       {
40862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40863       };
40864     } catch (...) {
40865       {
40866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40867       };
40868     }
40869   }
40870
40871 }
40872
40873
40874 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40875   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40876   Dali::Radian arg2 ;
40877   Dali::Radian *argp2 ;
40878
40879   arg1 = (Dali::PanGestureDetector *)jarg1;
40880   argp2 = (Dali::Radian *)jarg2;
40881   if (!argp2) {
40882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40883     return ;
40884   }
40885   arg2 = *argp2;
40886   {
40887     try {
40888       (arg1)->RemoveAngle(arg2);
40889     } catch (std::out_of_range& e) {
40890       {
40891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40892       };
40893     } catch (std::exception& e) {
40894       {
40895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40896       };
40897     } catch (Dali::DaliException e) {
40898       {
40899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40900       };
40901     } catch (...) {
40902       {
40903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40904       };
40905     }
40906   }
40907
40908 }
40909
40910
40911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40912   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40913   Dali::Radian arg2 ;
40914   Dali::Radian *argp2 ;
40915
40916   arg1 = (Dali::PanGestureDetector *)jarg1;
40917   argp2 = (Dali::Radian *)jarg2;
40918   if (!argp2) {
40919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40920     return ;
40921   }
40922   arg2 = *argp2;
40923   {
40924     try {
40925       (arg1)->RemoveDirection(arg2);
40926     } catch (std::out_of_range& e) {
40927       {
40928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40929       };
40930     } catch (std::exception& e) {
40931       {
40932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40933       };
40934     } catch (Dali::DaliException e) {
40935       {
40936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40937       };
40938     } catch (...) {
40939       {
40940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40941       };
40942     }
40943   }
40944
40945 }
40946
40947
40948 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40949   void * jresult ;
40950   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40951   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40952
40953   arg1 = (Dali::PanGestureDetector *)jarg1;
40954   {
40955     try {
40956       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
40957     } catch (std::out_of_range& e) {
40958       {
40959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40960       };
40961     } catch (std::exception& e) {
40962       {
40963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40964       };
40965     } catch (Dali::DaliException e) {
40966       {
40967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40968       };
40969     } catch (...) {
40970       {
40971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40972       };
40973     }
40974   }
40975
40976   jresult = (void *)result;
40977   return jresult;
40978 }
40979
40980
40981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetPanGestureProperties(void * jarg1) {
40982   Dali::PanGesture *arg1 = 0 ;
40983
40984   arg1 = (Dali::PanGesture *)jarg1;
40985   if (!arg1) {
40986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40987     return ;
40988   }
40989   {
40990     try {
40991       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40992     } catch (std::out_of_range& e) {
40993       {
40994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40995       };
40996     } catch (std::exception& e) {
40997       {
40998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40999       };
41000     } catch (Dali::DaliException e) {
41001       {
41002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41003       };
41004     } catch (...) {
41005       {
41006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41007       };
41008     }
41009   }
41010
41011 }
41012
41013
41014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
41015   void * jresult ;
41016   Dali::PanGesture *result = 0 ;
41017
41018   {
41019     try {
41020       result = (Dali::PanGesture *)new Dali::PanGesture();
41021     } catch (std::out_of_range& e) {
41022       {
41023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41024       };
41025     } catch (std::exception& e) {
41026       {
41027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41028       };
41029     } catch (Dali::DaliException e) {
41030       {
41031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41032       };
41033     } catch (...) {
41034       {
41035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41036       };
41037     }
41038   }
41039
41040   jresult = (void *)result;
41041   return jresult;
41042 }
41043
41044
41045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
41046   void * jresult ;
41047   Dali::Gesture::State arg1 ;
41048   Dali::PanGesture *result = 0 ;
41049
41050   arg1 = (Dali::Gesture::State)jarg1;
41051   {
41052     try {
41053       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
41054     } catch (std::out_of_range& e) {
41055       {
41056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41057       };
41058     } catch (std::exception& e) {
41059       {
41060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41061       };
41062     } catch (Dali::DaliException e) {
41063       {
41064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41065       };
41066     } catch (...) {
41067       {
41068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41069       };
41070     }
41071   }
41072
41073   jresult = (void *)result;
41074   return jresult;
41075 }
41076
41077
41078 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
41079   void * jresult ;
41080   Dali::PanGesture *arg1 = 0 ;
41081   Dali::PanGesture *result = 0 ;
41082
41083   arg1 = (Dali::PanGesture *)jarg1;
41084   if (!arg1) {
41085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41086     return 0;
41087   }
41088   {
41089     try {
41090       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
41091     } catch (std::out_of_range& e) {
41092       {
41093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41094       };
41095     } catch (std::exception& e) {
41096       {
41097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41098       };
41099     } catch (Dali::DaliException e) {
41100       {
41101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41102       };
41103     } catch (...) {
41104       {
41105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41106       };
41107     }
41108   }
41109
41110   jresult = (void *)result;
41111   return jresult;
41112 }
41113
41114
41115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
41116   void * jresult ;
41117   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41118   Dali::PanGesture *arg2 = 0 ;
41119   Dali::PanGesture *result = 0 ;
41120
41121   arg1 = (Dali::PanGesture *)jarg1;
41122   arg2 = (Dali::PanGesture *)jarg2;
41123   if (!arg2) {
41124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
41125     return 0;
41126   }
41127   {
41128     try {
41129       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
41130     } catch (std::out_of_range& e) {
41131       {
41132         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41133       };
41134     } catch (std::exception& e) {
41135       {
41136         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41137       };
41138     } catch (Dali::DaliException e) {
41139       {
41140         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41141       };
41142     } catch (...) {
41143       {
41144         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41145       };
41146     }
41147   }
41148
41149   jresult = (void *)result;
41150   return jresult;
41151 }
41152
41153
41154 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
41155   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41156
41157   arg1 = (Dali::PanGesture *)jarg1;
41158   {
41159     try {
41160       delete arg1;
41161     } catch (std::out_of_range& e) {
41162       {
41163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41164       };
41165     } catch (std::exception& e) {
41166       {
41167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41168       };
41169     } catch (Dali::DaliException e) {
41170       {
41171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41172       };
41173     } catch (...) {
41174       {
41175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41176       };
41177     }
41178   }
41179
41180 }
41181
41182
41183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
41184   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41185   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41186
41187   arg1 = (Dali::PanGesture *)jarg1;
41188   arg2 = (Dali::Vector2 *)jarg2;
41189   if (arg1) (arg1)->velocity = *arg2;
41190 }
41191
41192
41193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
41194   void * jresult ;
41195   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41196   Dali::Vector2 *result = 0 ;
41197
41198   arg1 = (Dali::PanGesture *)jarg1;
41199   result = (Dali::Vector2 *)& ((arg1)->velocity);
41200   jresult = (void *)result;
41201   return jresult;
41202 }
41203
41204
41205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
41206   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41207   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41208
41209   arg1 = (Dali::PanGesture *)jarg1;
41210   arg2 = (Dali::Vector2 *)jarg2;
41211   if (arg1) (arg1)->displacement = *arg2;
41212 }
41213
41214
41215 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
41216   void * jresult ;
41217   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41218   Dali::Vector2 *result = 0 ;
41219
41220   arg1 = (Dali::PanGesture *)jarg1;
41221   result = (Dali::Vector2 *)& ((arg1)->displacement);
41222   jresult = (void *)result;
41223   return jresult;
41224 }
41225
41226
41227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
41228   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41229   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41230
41231   arg1 = (Dali::PanGesture *)jarg1;
41232   arg2 = (Dali::Vector2 *)jarg2;
41233   if (arg1) (arg1)->position = *arg2;
41234 }
41235
41236
41237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
41238   void * jresult ;
41239   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41240   Dali::Vector2 *result = 0 ;
41241
41242   arg1 = (Dali::PanGesture *)jarg1;
41243   result = (Dali::Vector2 *)& ((arg1)->position);
41244   jresult = (void *)result;
41245   return jresult;
41246 }
41247
41248
41249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
41250   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41251   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41252
41253   arg1 = (Dali::PanGesture *)jarg1;
41254   arg2 = (Dali::Vector2 *)jarg2;
41255   if (arg1) (arg1)->screenVelocity = *arg2;
41256 }
41257
41258
41259 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
41260   void * jresult ;
41261   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41262   Dali::Vector2 *result = 0 ;
41263
41264   arg1 = (Dali::PanGesture *)jarg1;
41265   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
41266   jresult = (void *)result;
41267   return jresult;
41268 }
41269
41270
41271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
41272   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41273   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41274
41275   arg1 = (Dali::PanGesture *)jarg1;
41276   arg2 = (Dali::Vector2 *)jarg2;
41277   if (arg1) (arg1)->screenDisplacement = *arg2;
41278 }
41279
41280
41281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
41282   void * jresult ;
41283   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41284   Dali::Vector2 *result = 0 ;
41285
41286   arg1 = (Dali::PanGesture *)jarg1;
41287   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
41288   jresult = (void *)result;
41289   return jresult;
41290 }
41291
41292
41293 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
41294   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41295   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41296
41297   arg1 = (Dali::PanGesture *)jarg1;
41298   arg2 = (Dali::Vector2 *)jarg2;
41299   if (arg1) (arg1)->screenPosition = *arg2;
41300 }
41301
41302
41303 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
41304   void * jresult ;
41305   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41306   Dali::Vector2 *result = 0 ;
41307
41308   arg1 = (Dali::PanGesture *)jarg1;
41309   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
41310   jresult = (void *)result;
41311   return jresult;
41312 }
41313
41314
41315 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41316   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41317   unsigned int arg2 ;
41318
41319   arg1 = (Dali::PanGesture *)jarg1;
41320   arg2 = (unsigned int)jarg2;
41321   if (arg1) (arg1)->numberOfTouches = arg2;
41322 }
41323
41324
41325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
41326   unsigned int jresult ;
41327   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41328   unsigned int result;
41329
41330   arg1 = (Dali::PanGesture *)jarg1;
41331   result = (unsigned int) ((arg1)->numberOfTouches);
41332   jresult = result;
41333   return jresult;
41334 }
41335
41336
41337 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
41338   float jresult ;
41339   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41340   float result;
41341
41342   arg1 = (Dali::PanGesture *)jarg1;
41343   {
41344     try {
41345       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
41346     } catch (std::out_of_range& e) {
41347       {
41348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41349       };
41350     } catch (std::exception& e) {
41351       {
41352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41353       };
41354     } catch (Dali::DaliException e) {
41355       {
41356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41357       };
41358     } catch (...) {
41359       {
41360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41361       };
41362     }
41363   }
41364
41365   jresult = result;
41366   return jresult;
41367 }
41368
41369
41370 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
41371   float jresult ;
41372   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41373   float result;
41374
41375   arg1 = (Dali::PanGesture *)jarg1;
41376   {
41377     try {
41378       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
41379     } catch (std::out_of_range& e) {
41380       {
41381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41382       };
41383     } catch (std::exception& e) {
41384       {
41385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41386       };
41387     } catch (Dali::DaliException e) {
41388       {
41389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41390       };
41391     } catch (...) {
41392       {
41393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41394       };
41395     }
41396   }
41397
41398   jresult = result;
41399   return jresult;
41400 }
41401
41402
41403 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
41404   float jresult ;
41405   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41406   float result;
41407
41408   arg1 = (Dali::PanGesture *)jarg1;
41409   {
41410     try {
41411       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
41412     } catch (std::out_of_range& e) {
41413       {
41414         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41415       };
41416     } catch (std::exception& e) {
41417       {
41418         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41419       };
41420     } catch (Dali::DaliException e) {
41421       {
41422         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41423       };
41424     } catch (...) {
41425       {
41426         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41427       };
41428     }
41429   }
41430
41431   jresult = result;
41432   return jresult;
41433 }
41434
41435
41436 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
41437   float jresult ;
41438   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
41439   float result;
41440
41441   arg1 = (Dali::PanGesture *)jarg1;
41442   {
41443     try {
41444       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
41445     } catch (std::out_of_range& e) {
41446       {
41447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41448       };
41449     } catch (std::exception& e) {
41450       {
41451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41452       };
41453     } catch (Dali::DaliException e) {
41454       {
41455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41456       };
41457     } catch (...) {
41458       {
41459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41460       };
41461     }
41462   }
41463
41464   jresult = result;
41465   return jresult;
41466 }
41467
41468
41469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
41470   void * jresult ;
41471   Dali::PinchGestureDetector *result = 0 ;
41472
41473   {
41474     try {
41475       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
41476     } catch (std::out_of_range& e) {
41477       {
41478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41479       };
41480     } catch (std::exception& e) {
41481       {
41482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41483       };
41484     } catch (Dali::DaliException e) {
41485       {
41486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41487       };
41488     } catch (...) {
41489       {
41490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41491       };
41492     }
41493   }
41494
41495   jresult = (void *)result;
41496   return jresult;
41497 }
41498
41499
41500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41501   void * jresult ;
41502   Dali::PinchGestureDetector result;
41503
41504   {
41505     try {
41506       result = Dali::PinchGestureDetector::New();
41507     } catch (std::out_of_range& e) {
41508       {
41509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41510       };
41511     } catch (std::exception& e) {
41512       {
41513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41514       };
41515     } catch (Dali::DaliException e) {
41516       {
41517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41518       };
41519     } catch (...) {
41520       {
41521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41522       };
41523     }
41524   }
41525
41526   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41527   return jresult;
41528 }
41529
41530
41531 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41532   void * jresult ;
41533   Dali::BaseHandle arg1 ;
41534   Dali::BaseHandle *argp1 ;
41535   Dali::PinchGestureDetector result;
41536
41537   argp1 = (Dali::BaseHandle *)jarg1;
41538   if (!argp1) {
41539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41540     return 0;
41541   }
41542   arg1 = *argp1;
41543   {
41544     try {
41545       result = Dali::PinchGestureDetector::DownCast(arg1);
41546     } catch (std::out_of_range& e) {
41547       {
41548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41549       };
41550     } catch (std::exception& e) {
41551       {
41552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41553       };
41554     } catch (Dali::DaliException e) {
41555       {
41556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41557       };
41558     } catch (...) {
41559       {
41560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41561       };
41562     }
41563   }
41564
41565   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41566   return jresult;
41567 }
41568
41569
41570 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41571   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41572
41573   arg1 = (Dali::PinchGestureDetector *)jarg1;
41574   {
41575     try {
41576       delete arg1;
41577     } catch (std::out_of_range& e) {
41578       {
41579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41580       };
41581     } catch (std::exception& e) {
41582       {
41583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41584       };
41585     } catch (Dali::DaliException e) {
41586       {
41587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41588       };
41589     } catch (...) {
41590       {
41591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41592       };
41593     }
41594   }
41595
41596 }
41597
41598
41599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41600   void * jresult ;
41601   Dali::PinchGestureDetector *arg1 = 0 ;
41602   Dali::PinchGestureDetector *result = 0 ;
41603
41604   arg1 = (Dali::PinchGestureDetector *)jarg1;
41605   if (!arg1) {
41606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41607     return 0;
41608   }
41609   {
41610     try {
41611       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41612     } catch (std::out_of_range& e) {
41613       {
41614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41615       };
41616     } catch (std::exception& e) {
41617       {
41618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41619       };
41620     } catch (Dali::DaliException e) {
41621       {
41622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41623       };
41624     } catch (...) {
41625       {
41626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41627       };
41628     }
41629   }
41630
41631   jresult = (void *)result;
41632   return jresult;
41633 }
41634
41635
41636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41637   void * jresult ;
41638   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41639   Dali::PinchGestureDetector *arg2 = 0 ;
41640   Dali::PinchGestureDetector *result = 0 ;
41641
41642   arg1 = (Dali::PinchGestureDetector *)jarg1;
41643   arg2 = (Dali::PinchGestureDetector *)jarg2;
41644   if (!arg2) {
41645     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41646     return 0;
41647   }
41648   {
41649     try {
41650       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41651     } catch (std::out_of_range& e) {
41652       {
41653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41654       };
41655     } catch (std::exception& e) {
41656       {
41657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41658       };
41659     } catch (Dali::DaliException e) {
41660       {
41661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41662       };
41663     } catch (...) {
41664       {
41665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41666       };
41667     }
41668   }
41669
41670   jresult = (void *)result;
41671   return jresult;
41672 }
41673
41674
41675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41676   void * jresult ;
41677   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41678   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41679
41680   arg1 = (Dali::PinchGestureDetector *)jarg1;
41681   {
41682     try {
41683       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41684     } catch (std::out_of_range& e) {
41685       {
41686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41687       };
41688     } catch (std::exception& e) {
41689       {
41690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41691       };
41692     } catch (Dali::DaliException e) {
41693       {
41694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41695       };
41696     } catch (...) {
41697       {
41698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41699       };
41700     }
41701   }
41702
41703   jresult = (void *)result;
41704   return jresult;
41705 }
41706
41707
41708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41709   void * jresult ;
41710   Dali::Gesture::State arg1 ;
41711   Dali::PinchGesture *result = 0 ;
41712
41713   arg1 = (Dali::Gesture::State)jarg1;
41714   {
41715     try {
41716       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41724       };
41725     } catch (Dali::DaliException e) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41732       };
41733     }
41734   }
41735
41736   jresult = (void *)result;
41737   return jresult;
41738 }
41739
41740
41741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41742   void * jresult ;
41743   Dali::PinchGesture *arg1 = 0 ;
41744   Dali::PinchGesture *result = 0 ;
41745
41746   arg1 = (Dali::PinchGesture *)jarg1;
41747   if (!arg1) {
41748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41749     return 0;
41750   }
41751   {
41752     try {
41753       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41754     } catch (std::out_of_range& e) {
41755       {
41756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41757       };
41758     } catch (std::exception& e) {
41759       {
41760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41761       };
41762     } catch (Dali::DaliException e) {
41763       {
41764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41765       };
41766     } catch (...) {
41767       {
41768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41769       };
41770     }
41771   }
41772
41773   jresult = (void *)result;
41774   return jresult;
41775 }
41776
41777
41778 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41779   void * jresult ;
41780   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41781   Dali::PinchGesture *arg2 = 0 ;
41782   Dali::PinchGesture *result = 0 ;
41783
41784   arg1 = (Dali::PinchGesture *)jarg1;
41785   arg2 = (Dali::PinchGesture *)jarg2;
41786   if (!arg2) {
41787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41788     return 0;
41789   }
41790   {
41791     try {
41792       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41793     } catch (std::out_of_range& e) {
41794       {
41795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41796       };
41797     } catch (std::exception& e) {
41798       {
41799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41800       };
41801     } catch (Dali::DaliException e) {
41802       {
41803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41804       };
41805     } catch (...) {
41806       {
41807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41808       };
41809     }
41810   }
41811
41812   jresult = (void *)result;
41813   return jresult;
41814 }
41815
41816
41817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41818   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41819
41820   arg1 = (Dali::PinchGesture *)jarg1;
41821   {
41822     try {
41823       delete arg1;
41824     } catch (std::out_of_range& e) {
41825       {
41826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41827       };
41828     } catch (std::exception& e) {
41829       {
41830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41831       };
41832     } catch (Dali::DaliException e) {
41833       {
41834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41835       };
41836     } catch (...) {
41837       {
41838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41839       };
41840     }
41841   }
41842
41843 }
41844
41845
41846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41847   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41848   float arg2 ;
41849
41850   arg1 = (Dali::PinchGesture *)jarg1;
41851   arg2 = (float)jarg2;
41852   if (arg1) (arg1)->scale = arg2;
41853 }
41854
41855
41856 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41857   float jresult ;
41858   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41859   float result;
41860
41861   arg1 = (Dali::PinchGesture *)jarg1;
41862   result = (float) ((arg1)->scale);
41863   jresult = result;
41864   return jresult;
41865 }
41866
41867
41868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41869   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41870   float arg2 ;
41871
41872   arg1 = (Dali::PinchGesture *)jarg1;
41873   arg2 = (float)jarg2;
41874   if (arg1) (arg1)->speed = arg2;
41875 }
41876
41877
41878 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41879   float jresult ;
41880   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41881   float result;
41882
41883   arg1 = (Dali::PinchGesture *)jarg1;
41884   result = (float) ((arg1)->speed);
41885   jresult = result;
41886   return jresult;
41887 }
41888
41889
41890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41891   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41892   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41893
41894   arg1 = (Dali::PinchGesture *)jarg1;
41895   arg2 = (Dali::Vector2 *)jarg2;
41896   if (arg1) (arg1)->screenCenterPoint = *arg2;
41897 }
41898
41899
41900 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41901   void * jresult ;
41902   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41903   Dali::Vector2 *result = 0 ;
41904
41905   arg1 = (Dali::PinchGesture *)jarg1;
41906   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41907   jresult = (void *)result;
41908   return jresult;
41909 }
41910
41911
41912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41913   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41914   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41915
41916   arg1 = (Dali::PinchGesture *)jarg1;
41917   arg2 = (Dali::Vector2 *)jarg2;
41918   if (arg1) (arg1)->localCenterPoint = *arg2;
41919 }
41920
41921
41922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41923   void * jresult ;
41924   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41925   Dali::Vector2 *result = 0 ;
41926
41927   arg1 = (Dali::PinchGesture *)jarg1;
41928   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41929   jresult = (void *)result;
41930   return jresult;
41931 }
41932
41933
41934 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41935   void * jresult ;
41936   Dali::TapGestureDetector *result = 0 ;
41937
41938   {
41939     try {
41940       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
41941     } catch (std::out_of_range& e) {
41942       {
41943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41944       };
41945     } catch (std::exception& e) {
41946       {
41947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41948       };
41949     } catch (Dali::DaliException e) {
41950       {
41951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41952       };
41953     } catch (...) {
41954       {
41955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41956       };
41957     }
41958   }
41959
41960   jresult = (void *)result;
41961   return jresult;
41962 }
41963
41964
41965 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41966   void * jresult ;
41967   Dali::TapGestureDetector result;
41968
41969   {
41970     try {
41971       result = Dali::TapGestureDetector::New();
41972     } catch (std::out_of_range& e) {
41973       {
41974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41975       };
41976     } catch (std::exception& e) {
41977       {
41978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41979       };
41980     } catch (Dali::DaliException e) {
41981       {
41982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41983       };
41984     } catch (...) {
41985       {
41986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41987       };
41988     }
41989   }
41990
41991   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41992   return jresult;
41993 }
41994
41995
41996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41997   void * jresult ;
41998   unsigned int arg1 ;
41999   Dali::TapGestureDetector result;
42000
42001   arg1 = (unsigned int)jarg1;
42002   {
42003     try {
42004       result = Dali::TapGestureDetector::New(arg1);
42005     } catch (std::out_of_range& e) {
42006       {
42007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42008       };
42009     } catch (std::exception& e) {
42010       {
42011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42012       };
42013     } catch (Dali::DaliException e) {
42014       {
42015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42016       };
42017     } catch (...) {
42018       {
42019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42020       };
42021     }
42022   }
42023
42024   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42025   return jresult;
42026 }
42027
42028
42029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
42030   void * jresult ;
42031   Dali::BaseHandle arg1 ;
42032   Dali::BaseHandle *argp1 ;
42033   Dali::TapGestureDetector result;
42034
42035   argp1 = (Dali::BaseHandle *)jarg1;
42036   if (!argp1) {
42037     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42038     return 0;
42039   }
42040   arg1 = *argp1;
42041   {
42042     try {
42043       result = Dali::TapGestureDetector::DownCast(arg1);
42044     } catch (std::out_of_range& e) {
42045       {
42046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42047       };
42048     } catch (std::exception& e) {
42049       {
42050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42051       };
42052     } catch (Dali::DaliException e) {
42053       {
42054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42055       };
42056     } catch (...) {
42057       {
42058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42059       };
42060     }
42061   }
42062
42063   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
42064   return jresult;
42065 }
42066
42067
42068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
42069   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42070
42071   arg1 = (Dali::TapGestureDetector *)jarg1;
42072   {
42073     try {
42074       delete arg1;
42075     } catch (std::out_of_range& e) {
42076       {
42077         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42078       };
42079     } catch (std::exception& e) {
42080       {
42081         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42082       };
42083     } catch (Dali::DaliException e) {
42084       {
42085         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42086       };
42087     } catch (...) {
42088       {
42089         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42090       };
42091     }
42092   }
42093
42094 }
42095
42096
42097 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
42098   void * jresult ;
42099   Dali::TapGestureDetector *arg1 = 0 ;
42100   Dali::TapGestureDetector *result = 0 ;
42101
42102   arg1 = (Dali::TapGestureDetector *)jarg1;
42103   if (!arg1) {
42104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42105     return 0;
42106   }
42107   {
42108     try {
42109       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
42110     } catch (std::out_of_range& e) {
42111       {
42112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42113       };
42114     } catch (std::exception& e) {
42115       {
42116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42117       };
42118     } catch (Dali::DaliException e) {
42119       {
42120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42121       };
42122     } catch (...) {
42123       {
42124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42125       };
42126     }
42127   }
42128
42129   jresult = (void *)result;
42130   return jresult;
42131 }
42132
42133
42134 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
42135   void * jresult ;
42136   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42137   Dali::TapGestureDetector *arg2 = 0 ;
42138   Dali::TapGestureDetector *result = 0 ;
42139
42140   arg1 = (Dali::TapGestureDetector *)jarg1;
42141   arg2 = (Dali::TapGestureDetector *)jarg2;
42142   if (!arg2) {
42143     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
42144     return 0;
42145   }
42146   {
42147     try {
42148       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
42149     } catch (std::out_of_range& e) {
42150       {
42151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42152       };
42153     } catch (std::exception& e) {
42154       {
42155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42156       };
42157     } catch (Dali::DaliException e) {
42158       {
42159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42160       };
42161     } catch (...) {
42162       {
42163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42164       };
42165     }
42166   }
42167
42168   jresult = (void *)result;
42169   return jresult;
42170 }
42171
42172
42173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
42174   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42175   unsigned int arg2 ;
42176
42177   arg1 = (Dali::TapGestureDetector *)jarg1;
42178   arg2 = (unsigned int)jarg2;
42179   {
42180     try {
42181       (arg1)->SetMinimumTapsRequired(arg2);
42182     } catch (std::out_of_range& e) {
42183       {
42184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42185       };
42186     } catch (std::exception& e) {
42187       {
42188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42189       };
42190     } catch (Dali::DaliException e) {
42191       {
42192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42193       };
42194     } catch (...) {
42195       {
42196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42197       };
42198     }
42199   }
42200
42201 }
42202
42203
42204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
42205   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42206   unsigned int arg2 ;
42207
42208   arg1 = (Dali::TapGestureDetector *)jarg1;
42209   arg2 = (unsigned int)jarg2;
42210   {
42211     try {
42212       (arg1)->SetMaximumTapsRequired(arg2);
42213     } catch (std::out_of_range& e) {
42214       {
42215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42216       };
42217     } catch (std::exception& e) {
42218       {
42219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42220       };
42221     } catch (Dali::DaliException e) {
42222       {
42223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42224       };
42225     } catch (...) {
42226       {
42227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42228       };
42229     }
42230   }
42231
42232 }
42233
42234
42235 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
42236   unsigned int jresult ;
42237   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42238   unsigned int result;
42239
42240   arg1 = (Dali::TapGestureDetector *)jarg1;
42241   {
42242     try {
42243       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
42244     } catch (std::out_of_range& e) {
42245       {
42246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42247       };
42248     } catch (std::exception& e) {
42249       {
42250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42251       };
42252     } catch (Dali::DaliException e) {
42253       {
42254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42255       };
42256     } catch (...) {
42257       {
42258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42259       };
42260     }
42261   }
42262
42263   jresult = result;
42264   return jresult;
42265 }
42266
42267
42268 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
42269   unsigned int jresult ;
42270   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42271   unsigned int result;
42272
42273   arg1 = (Dali::TapGestureDetector *)jarg1;
42274   {
42275     try {
42276       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
42277     } catch (std::out_of_range& e) {
42278       {
42279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42280       };
42281     } catch (std::exception& e) {
42282       {
42283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42284       };
42285     } catch (Dali::DaliException e) {
42286       {
42287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42288       };
42289     } catch (...) {
42290       {
42291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42292       };
42293     }
42294   }
42295
42296   jresult = result;
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
42302   void * jresult ;
42303   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
42304   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
42305
42306   arg1 = (Dali::TapGestureDetector *)jarg1;
42307   {
42308     try {
42309       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
42310     } catch (std::out_of_range& e) {
42311       {
42312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42313       };
42314     } catch (std::exception& e) {
42315       {
42316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42317       };
42318     } catch (Dali::DaliException e) {
42319       {
42320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42321       };
42322     } catch (...) {
42323       {
42324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42325       };
42326     }
42327   }
42328
42329   jresult = (void *)result;
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
42335   void * jresult ;
42336   Dali::TapGesture *result = 0 ;
42337
42338   {
42339     try {
42340       result = (Dali::TapGesture *)new Dali::TapGesture();
42341     } catch (std::out_of_range& e) {
42342       {
42343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42344       };
42345     } catch (std::exception& e) {
42346       {
42347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42348       };
42349     } catch (Dali::DaliException e) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42352       };
42353     } catch (...) {
42354       {
42355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42356       };
42357     }
42358   }
42359
42360   jresult = (void *)result;
42361   return jresult;
42362 }
42363
42364
42365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
42366   void * jresult ;
42367   Dali::TapGesture *arg1 = 0 ;
42368   Dali::TapGesture *result = 0 ;
42369
42370   arg1 = (Dali::TapGesture *)jarg1;
42371   if (!arg1) {
42372     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42373     return 0;
42374   }
42375   {
42376     try {
42377       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
42378     } catch (std::out_of_range& e) {
42379       {
42380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42381       };
42382     } catch (std::exception& e) {
42383       {
42384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42385       };
42386     } catch (Dali::DaliException e) {
42387       {
42388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42389       };
42390     } catch (...) {
42391       {
42392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42393       };
42394     }
42395   }
42396
42397   jresult = (void *)result;
42398   return jresult;
42399 }
42400
42401
42402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
42403   void * jresult ;
42404   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42405   Dali::TapGesture *arg2 = 0 ;
42406   Dali::TapGesture *result = 0 ;
42407
42408   arg1 = (Dali::TapGesture *)jarg1;
42409   arg2 = (Dali::TapGesture *)jarg2;
42410   if (!arg2) {
42411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
42412     return 0;
42413   }
42414   {
42415     try {
42416       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
42417     } catch (std::out_of_range& e) {
42418       {
42419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42420       };
42421     } catch (std::exception& e) {
42422       {
42423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42424       };
42425     } catch (Dali::DaliException e) {
42426       {
42427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42428       };
42429     } catch (...) {
42430       {
42431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42432       };
42433     }
42434   }
42435
42436   jresult = (void *)result;
42437   return jresult;
42438 }
42439
42440
42441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
42442   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42443
42444   arg1 = (Dali::TapGesture *)jarg1;
42445   {
42446     try {
42447       delete arg1;
42448     } catch (std::out_of_range& e) {
42449       {
42450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42451       };
42452     } catch (std::exception& e) {
42453       {
42454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42455       };
42456     } catch (Dali::DaliException e) {
42457       {
42458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42459       };
42460     } catch (...) {
42461       {
42462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42463       };
42464     }
42465   }
42466
42467 }
42468
42469
42470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
42471   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42472   unsigned int arg2 ;
42473
42474   arg1 = (Dali::TapGesture *)jarg1;
42475   arg2 = (unsigned int)jarg2;
42476   if (arg1) (arg1)->numberOfTaps = arg2;
42477 }
42478
42479
42480 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
42481   unsigned int jresult ;
42482   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42483   unsigned int result;
42484
42485   arg1 = (Dali::TapGesture *)jarg1;
42486   result = (unsigned int) ((arg1)->numberOfTaps);
42487   jresult = result;
42488   return jresult;
42489 }
42490
42491
42492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
42493   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42494   unsigned int arg2 ;
42495
42496   arg1 = (Dali::TapGesture *)jarg1;
42497   arg2 = (unsigned int)jarg2;
42498   if (arg1) (arg1)->numberOfTouches = arg2;
42499 }
42500
42501
42502 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42503   unsigned int jresult ;
42504   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42505   unsigned int result;
42506
42507   arg1 = (Dali::TapGesture *)jarg1;
42508   result = (unsigned int) ((arg1)->numberOfTouches);
42509   jresult = result;
42510   return jresult;
42511 }
42512
42513
42514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42515   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42516   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42517
42518   arg1 = (Dali::TapGesture *)jarg1;
42519   arg2 = (Dali::Vector2 *)jarg2;
42520   if (arg1) (arg1)->screenPoint = *arg2;
42521 }
42522
42523
42524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42525   void * jresult ;
42526   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42527   Dali::Vector2 *result = 0 ;
42528
42529   arg1 = (Dali::TapGesture *)jarg1;
42530   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42531   jresult = (void *)result;
42532   return jresult;
42533 }
42534
42535
42536 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42537   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42538   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42539
42540   arg1 = (Dali::TapGesture *)jarg1;
42541   arg2 = (Dali::Vector2 *)jarg2;
42542   if (arg1) (arg1)->localPoint = *arg2;
42543 }
42544
42545
42546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42547   void * jresult ;
42548   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42549   Dali::Vector2 *result = 0 ;
42550
42551   arg1 = (Dali::TapGesture *)jarg1;
42552   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42553   jresult = (void *)result;
42554   return jresult;
42555 }
42556
42557
42558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42559   void * jresult ;
42560   Dali::AlphaFunction *result = 0 ;
42561
42562   {
42563     try {
42564       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42565     } catch (std::out_of_range& e) {
42566       {
42567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42568       };
42569     } catch (std::exception& e) {
42570       {
42571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42572       };
42573     } catch (Dali::DaliException e) {
42574       {
42575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42576       };
42577     } catch (...) {
42578       {
42579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42580       };
42581     }
42582   }
42583
42584   jresult = (void *)result;
42585   return jresult;
42586 }
42587
42588
42589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42590   void * jresult ;
42591   Dali::AlphaFunction::BuiltinFunction arg1 ;
42592   Dali::AlphaFunction *result = 0 ;
42593
42594   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42595   {
42596     try {
42597       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42598     } catch (std::out_of_range& e) {
42599       {
42600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42601       };
42602     } catch (std::exception& e) {
42603       {
42604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42605       };
42606     } catch (Dali::DaliException e) {
42607       {
42608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42609       };
42610     } catch (...) {
42611       {
42612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42613       };
42614     }
42615   }
42616
42617   jresult = (void *)result;
42618   return jresult;
42619 }
42620
42621
42622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42623   void * jresult ;
42624   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42625   Dali::AlphaFunction *result = 0 ;
42626
42627   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42628   {
42629     try {
42630       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42631     } catch (std::out_of_range& e) {
42632       {
42633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42634       };
42635     } catch (std::exception& e) {
42636       {
42637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42638       };
42639     } catch (Dali::DaliException e) {
42640       {
42641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42642       };
42643     } catch (...) {
42644       {
42645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42646       };
42647     }
42648   }
42649
42650   jresult = (void *)result;
42651   return jresult;
42652 }
42653
42654
42655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42656   void * jresult ;
42657   Dali::Vector2 *arg1 = 0 ;
42658   Dali::Vector2 *arg2 = 0 ;
42659   Dali::AlphaFunction *result = 0 ;
42660
42661   arg1 = (Dali::Vector2 *)jarg1;
42662   if (!arg1) {
42663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42664     return 0;
42665   }
42666   arg2 = (Dali::Vector2 *)jarg2;
42667   if (!arg2) {
42668     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42669     return 0;
42670   }
42671   {
42672     try {
42673       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42674     } catch (std::out_of_range& e) {
42675       {
42676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42677       };
42678     } catch (std::exception& e) {
42679       {
42680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42681       };
42682     } catch (Dali::DaliException e) {
42683       {
42684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42685       };
42686     } catch (...) {
42687       {
42688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42689       };
42690     }
42691   }
42692
42693   jresult = (void *)result;
42694   return jresult;
42695 }
42696
42697
42698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42699   void * jresult ;
42700   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42701   Dali::Vector4 result;
42702
42703   arg1 = (Dali::AlphaFunction *)jarg1;
42704   {
42705     try {
42706       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42707     } catch (std::out_of_range& e) {
42708       {
42709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42710       };
42711     } catch (std::exception& e) {
42712       {
42713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42714       };
42715     } catch (Dali::DaliException e) {
42716       {
42717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42718       };
42719     } catch (...) {
42720       {
42721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42722       };
42723     }
42724   }
42725
42726   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42727   return jresult;
42728 }
42729
42730
42731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42732   void * jresult ;
42733   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42734   Dali::AlphaFunctionPrototype result;
42735
42736   arg1 = (Dali::AlphaFunction *)jarg1;
42737   {
42738     try {
42739       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
42740     } catch (std::out_of_range& e) {
42741       {
42742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42743       };
42744     } catch (std::exception& e) {
42745       {
42746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42747       };
42748     } catch (Dali::DaliException e) {
42749       {
42750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42751       };
42752     } catch (...) {
42753       {
42754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42755       };
42756     }
42757   }
42758
42759   jresult = (void *)result;
42760   return jresult;
42761 }
42762
42763
42764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42765   int jresult ;
42766   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42767   Dali::AlphaFunction::BuiltinFunction result;
42768
42769   arg1 = (Dali::AlphaFunction *)jarg1;
42770   {
42771     try {
42772       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
42773     } catch (std::out_of_range& e) {
42774       {
42775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42776       };
42777     } catch (std::exception& e) {
42778       {
42779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42780       };
42781     } catch (Dali::DaliException e) {
42782       {
42783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42784       };
42785     } catch (...) {
42786       {
42787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42788       };
42789     }
42790   }
42791
42792   jresult = (int)result;
42793   return jresult;
42794 }
42795
42796
42797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42798   int jresult ;
42799   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42800   Dali::AlphaFunction::Mode result;
42801
42802   arg1 = (Dali::AlphaFunction *)jarg1;
42803   {
42804     try {
42805       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
42806     } catch (std::out_of_range& e) {
42807       {
42808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42809       };
42810     } catch (std::exception& e) {
42811       {
42812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42813       };
42814     } catch (Dali::DaliException e) {
42815       {
42816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42817       };
42818     } catch (...) {
42819       {
42820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42821       };
42822     }
42823   }
42824
42825   jresult = (int)result;
42826   return jresult;
42827 }
42828
42829
42830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42831   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42832
42833   arg1 = (Dali::AlphaFunction *)jarg1;
42834   {
42835     try {
42836       delete arg1;
42837     } catch (std::out_of_range& e) {
42838       {
42839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42840       };
42841     } catch (std::exception& e) {
42842       {
42843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42844       };
42845     } catch (Dali::DaliException e) {
42846       {
42847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42848       };
42849     } catch (...) {
42850       {
42851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42852       };
42853     }
42854   }
42855
42856 }
42857
42858
42859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42860   void * jresult ;
42861   Dali::KeyFrames result;
42862
42863   {
42864     try {
42865       result = Dali::KeyFrames::New();
42866     } catch (std::out_of_range& e) {
42867       {
42868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42869       };
42870     } catch (std::exception& e) {
42871       {
42872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42873       };
42874     } catch (Dali::DaliException e) {
42875       {
42876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42877       };
42878     } catch (...) {
42879       {
42880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42881       };
42882     }
42883   }
42884
42885   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42886   return jresult;
42887 }
42888
42889
42890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42891   void * jresult ;
42892   Dali::BaseHandle arg1 ;
42893   Dali::BaseHandle *argp1 ;
42894   Dali::KeyFrames result;
42895
42896   argp1 = (Dali::BaseHandle *)jarg1;
42897   if (!argp1) {
42898     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42899     return 0;
42900   }
42901   arg1 = *argp1;
42902   {
42903     try {
42904       result = Dali::KeyFrames::DownCast(arg1);
42905     } catch (std::out_of_range& e) {
42906       {
42907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42908       };
42909     } catch (std::exception& e) {
42910       {
42911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42912       };
42913     } catch (Dali::DaliException e) {
42914       {
42915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42916       };
42917     } catch (...) {
42918       {
42919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42920       };
42921     }
42922   }
42923
42924   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42925   return jresult;
42926 }
42927
42928
42929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42930   void * jresult ;
42931   Dali::KeyFrames *result = 0 ;
42932
42933   {
42934     try {
42935       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42936     } catch (std::out_of_range& e) {
42937       {
42938         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42939       };
42940     } catch (std::exception& e) {
42941       {
42942         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42943       };
42944     } catch (Dali::DaliException e) {
42945       {
42946         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42947       };
42948     } catch (...) {
42949       {
42950         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42951       };
42952     }
42953   }
42954
42955   jresult = (void *)result;
42956   return jresult;
42957 }
42958
42959
42960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42961   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42962
42963   arg1 = (Dali::KeyFrames *)jarg1;
42964   {
42965     try {
42966       delete arg1;
42967     } catch (std::out_of_range& e) {
42968       {
42969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42970       };
42971     } catch (std::exception& e) {
42972       {
42973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42974       };
42975     } catch (Dali::DaliException e) {
42976       {
42977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42978       };
42979     } catch (...) {
42980       {
42981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42982       };
42983     }
42984   }
42985
42986 }
42987
42988
42989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42990   void * jresult ;
42991   Dali::KeyFrames *arg1 = 0 ;
42992   Dali::KeyFrames *result = 0 ;
42993
42994   arg1 = (Dali::KeyFrames *)jarg1;
42995   if (!arg1) {
42996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42997     return 0;
42998   }
42999   {
43000     try {
43001       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
43002     } catch (std::out_of_range& e) {
43003       {
43004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43005       };
43006     } catch (std::exception& e) {
43007       {
43008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43009       };
43010     } catch (Dali::DaliException e) {
43011       {
43012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43013       };
43014     } catch (...) {
43015       {
43016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43017       };
43018     }
43019   }
43020
43021   jresult = (void *)result;
43022   return jresult;
43023 }
43024
43025
43026 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
43027   void * jresult ;
43028   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43029   Dali::KeyFrames *arg2 = 0 ;
43030   Dali::KeyFrames *result = 0 ;
43031
43032   arg1 = (Dali::KeyFrames *)jarg1;
43033   arg2 = (Dali::KeyFrames *)jarg2;
43034   if (!arg2) {
43035     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
43036     return 0;
43037   }
43038   {
43039     try {
43040       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
43041     } catch (std::out_of_range& e) {
43042       {
43043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43044       };
43045     } catch (std::exception& e) {
43046       {
43047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43048       };
43049     } catch (Dali::DaliException e) {
43050       {
43051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43052       };
43053     } catch (...) {
43054       {
43055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43056       };
43057     }
43058   }
43059
43060   jresult = (void *)result;
43061   return jresult;
43062 }
43063
43064
43065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
43066   int jresult ;
43067   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43068   Dali::Property::Type result;
43069
43070   arg1 = (Dali::KeyFrames *)jarg1;
43071   {
43072     try {
43073       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
43074     } catch (std::out_of_range& e) {
43075       {
43076         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43077       };
43078     } catch (std::exception& e) {
43079       {
43080         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43081       };
43082     } catch (Dali::DaliException e) {
43083       {
43084         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43085       };
43086     } catch (...) {
43087       {
43088         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43089       };
43090     }
43091   }
43092
43093   jresult = (int)result;
43094   return jresult;
43095 }
43096
43097
43098 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
43099   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43100   float arg2 ;
43101   Dali::Property::Value arg3 ;
43102   Dali::Property::Value *argp3 ;
43103
43104   arg1 = (Dali::KeyFrames *)jarg1;
43105   arg2 = (float)jarg2;
43106   argp3 = (Dali::Property::Value *)jarg3;
43107   if (!argp3) {
43108     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43109     return ;
43110   }
43111   arg3 = *argp3;
43112   {
43113     try {
43114       (arg1)->Add(arg2,arg3);
43115     } catch (std::out_of_range& e) {
43116       {
43117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43118       };
43119     } catch (std::exception& e) {
43120       {
43121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43122       };
43123     } catch (Dali::DaliException e) {
43124       {
43125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43126       };
43127     } catch (...) {
43128       {
43129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43130       };
43131     }
43132   }
43133
43134 }
43135
43136
43137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43138   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
43139   float arg2 ;
43140   Dali::Property::Value arg3 ;
43141   Dali::AlphaFunction arg4 ;
43142   Dali::Property::Value *argp3 ;
43143   Dali::AlphaFunction *argp4 ;
43144
43145   arg1 = (Dali::KeyFrames *)jarg1;
43146   arg2 = (float)jarg2;
43147   argp3 = (Dali::Property::Value *)jarg3;
43148   if (!argp3) {
43149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
43150     return ;
43151   }
43152   arg3 = *argp3;
43153   argp4 = (Dali::AlphaFunction *)jarg4;
43154   if (!argp4) {
43155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
43156     return ;
43157   }
43158   arg4 = *argp4;
43159   {
43160     try {
43161       (arg1)->Add(arg2,arg3,arg4);
43162     } catch (std::out_of_range& e) {
43163       {
43164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43165       };
43166     } catch (std::exception& e) {
43167       {
43168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43169       };
43170     } catch (Dali::DaliException e) {
43171       {
43172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43173       };
43174     } catch (...) {
43175       {
43176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43177       };
43178     }
43179   }
43180
43181 }
43182
43183
43184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
43185   int jresult ;
43186   int result;
43187
43188   result = (int)Dali::Path::Property::POINTS;
43189   jresult = (int)result;
43190   return jresult;
43191 }
43192
43193
43194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
43195   int jresult ;
43196   int result;
43197
43198   result = (int)Dali::Path::Property::CONTROL_POINTS;
43199   jresult = (int)result;
43200   return jresult;
43201 }
43202
43203
43204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
43205   void * jresult ;
43206   Dali::Path::Property *result = 0 ;
43207
43208   {
43209     try {
43210       result = (Dali::Path::Property *)new Dali::Path::Property();
43211     } catch (std::out_of_range& e) {
43212       {
43213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43214       };
43215     } catch (std::exception& e) {
43216       {
43217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43218       };
43219     } catch (Dali::DaliException e) {
43220       {
43221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43222       };
43223     } catch (...) {
43224       {
43225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43226       };
43227     }
43228   }
43229
43230   jresult = (void *)result;
43231   return jresult;
43232 }
43233
43234
43235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
43236   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
43237
43238   arg1 = (Dali::Path::Property *)jarg1;
43239   {
43240     try {
43241       delete arg1;
43242     } catch (std::out_of_range& e) {
43243       {
43244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43245       };
43246     } catch (std::exception& e) {
43247       {
43248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43249       };
43250     } catch (Dali::DaliException e) {
43251       {
43252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43253       };
43254     } catch (...) {
43255       {
43256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43257       };
43258     }
43259   }
43260
43261 }
43262
43263
43264 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
43265   void * jresult ;
43266   Dali::Path result;
43267
43268   {
43269     try {
43270       result = Dali::Path::New();
43271     } catch (std::out_of_range& e) {
43272       {
43273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43274       };
43275     } catch (std::exception& e) {
43276       {
43277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43278       };
43279     } catch (Dali::DaliException e) {
43280       {
43281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43282       };
43283     } catch (...) {
43284       {
43285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43286       };
43287     }
43288   }
43289
43290   jresult = new Dali::Path((const Dali::Path &)result);
43291   return jresult;
43292 }
43293
43294
43295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
43296   void * jresult ;
43297   Dali::BaseHandle arg1 ;
43298   Dali::BaseHandle *argp1 ;
43299   Dali::Path result;
43300
43301   argp1 = (Dali::BaseHandle *)jarg1;
43302   if (!argp1) {
43303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43304     return 0;
43305   }
43306   arg1 = *argp1;
43307   {
43308     try {
43309       result = Dali::Path::DownCast(arg1);
43310     } catch (std::out_of_range& e) {
43311       {
43312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43313       };
43314     } catch (std::exception& e) {
43315       {
43316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43317       };
43318     } catch (Dali::DaliException e) {
43319       {
43320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43321       };
43322     } catch (...) {
43323       {
43324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43325       };
43326     }
43327   }
43328
43329   jresult = new Dali::Path((const Dali::Path &)result);
43330   return jresult;
43331 }
43332
43333
43334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
43335   void * jresult ;
43336   Dali::Path *result = 0 ;
43337
43338   {
43339     try {
43340       result = (Dali::Path *)new Dali::Path();
43341     } catch (std::out_of_range& e) {
43342       {
43343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43344       };
43345     } catch (std::exception& e) {
43346       {
43347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43348       };
43349     } catch (Dali::DaliException e) {
43350       {
43351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43352       };
43353     } catch (...) {
43354       {
43355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43356       };
43357     }
43358   }
43359
43360   jresult = (void *)result;
43361   return jresult;
43362 }
43363
43364
43365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
43366   Dali::Path *arg1 = (Dali::Path *) 0 ;
43367
43368   arg1 = (Dali::Path *)jarg1;
43369   {
43370     try {
43371       delete arg1;
43372     } catch (std::out_of_range& e) {
43373       {
43374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43375       };
43376     } catch (std::exception& e) {
43377       {
43378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43379       };
43380     } catch (Dali::DaliException e) {
43381       {
43382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43383       };
43384     } catch (...) {
43385       {
43386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43387       };
43388     }
43389   }
43390
43391 }
43392
43393
43394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
43395   void * jresult ;
43396   Dali::Path *arg1 = 0 ;
43397   Dali::Path *result = 0 ;
43398
43399   arg1 = (Dali::Path *)jarg1;
43400   if (!arg1) {
43401     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43402     return 0;
43403   }
43404   {
43405     try {
43406       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
43407     } catch (std::out_of_range& e) {
43408       {
43409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43410       };
43411     } catch (std::exception& e) {
43412       {
43413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43414       };
43415     } catch (Dali::DaliException e) {
43416       {
43417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43418       };
43419     } catch (...) {
43420       {
43421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43422       };
43423     }
43424   }
43425
43426   jresult = (void *)result;
43427   return jresult;
43428 }
43429
43430
43431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
43432   void * jresult ;
43433   Dali::Path *arg1 = (Dali::Path *) 0 ;
43434   Dali::Path *arg2 = 0 ;
43435   Dali::Path *result = 0 ;
43436
43437   arg1 = (Dali::Path *)jarg1;
43438   arg2 = (Dali::Path *)jarg2;
43439   if (!arg2) {
43440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
43441     return 0;
43442   }
43443   {
43444     try {
43445       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
43446     } catch (std::out_of_range& e) {
43447       {
43448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43449       };
43450     } catch (std::exception& e) {
43451       {
43452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43453       };
43454     } catch (Dali::DaliException e) {
43455       {
43456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43457       };
43458     } catch (...) {
43459       {
43460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43461       };
43462     }
43463   }
43464
43465   jresult = (void *)result;
43466   return jresult;
43467 }
43468
43469
43470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
43471   Dali::Path *arg1 = (Dali::Path *) 0 ;
43472   Dali::Vector3 *arg2 = 0 ;
43473
43474   arg1 = (Dali::Path *)jarg1;
43475   arg2 = (Dali::Vector3 *)jarg2;
43476   if (!arg2) {
43477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43478     return ;
43479   }
43480   {
43481     try {
43482       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
43483     } catch (std::out_of_range& e) {
43484       {
43485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43486       };
43487     } catch (std::exception& e) {
43488       {
43489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43490       };
43491     } catch (Dali::DaliException e) {
43492       {
43493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43494       };
43495     } catch (...) {
43496       {
43497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43498       };
43499     }
43500   }
43501
43502 }
43503
43504
43505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43506   Dali::Path *arg1 = (Dali::Path *) 0 ;
43507   Dali::Vector3 *arg2 = 0 ;
43508
43509   arg1 = (Dali::Path *)jarg1;
43510   arg2 = (Dali::Vector3 *)jarg2;
43511   if (!arg2) {
43512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43513     return ;
43514   }
43515   {
43516     try {
43517       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43518     } catch (std::out_of_range& e) {
43519       {
43520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43521       };
43522     } catch (std::exception& e) {
43523       {
43524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43525       };
43526     } catch (Dali::DaliException e) {
43527       {
43528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43529       };
43530     } catch (...) {
43531       {
43532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43533       };
43534     }
43535   }
43536
43537 }
43538
43539
43540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43541   Dali::Path *arg1 = (Dali::Path *) 0 ;
43542   float arg2 ;
43543
43544   arg1 = (Dali::Path *)jarg1;
43545   arg2 = (float)jarg2;
43546   {
43547     try {
43548       (arg1)->GenerateControlPoints(arg2);
43549     } catch (std::out_of_range& e) {
43550       {
43551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43552       };
43553     } catch (std::exception& e) {
43554       {
43555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43556       };
43557     } catch (Dali::DaliException e) {
43558       {
43559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43560       };
43561     } catch (...) {
43562       {
43563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43564       };
43565     }
43566   }
43567
43568 }
43569
43570
43571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43572   Dali::Path *arg1 = (Dali::Path *) 0 ;
43573   float arg2 ;
43574   Dali::Vector3 *arg3 = 0 ;
43575   Dali::Vector3 *arg4 = 0 ;
43576
43577   arg1 = (Dali::Path *)jarg1;
43578   arg2 = (float)jarg2;
43579   arg3 = (Dali::Vector3 *)jarg3;
43580   if (!arg3) {
43581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43582     return ;
43583   }
43584   arg4 = (Dali::Vector3 *)jarg4;
43585   if (!arg4) {
43586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43587     return ;
43588   }
43589   {
43590     try {
43591       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43592     } catch (std::out_of_range& e) {
43593       {
43594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43595       };
43596     } catch (std::exception& e) {
43597       {
43598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43599       };
43600     } catch (Dali::DaliException e) {
43601       {
43602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43603       };
43604     } catch (...) {
43605       {
43606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43607       };
43608     }
43609   }
43610
43611 }
43612
43613
43614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43615   void * jresult ;
43616   Dali::Path *arg1 = (Dali::Path *) 0 ;
43617   size_t arg2 ;
43618   Dali::Vector3 *result = 0 ;
43619
43620   arg1 = (Dali::Path *)jarg1;
43621   arg2 = (size_t)jarg2;
43622   {
43623     try {
43624       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43625     } catch (std::out_of_range& e) {
43626       {
43627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43628       };
43629     } catch (std::exception& e) {
43630       {
43631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43632       };
43633     } catch (Dali::DaliException e) {
43634       {
43635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43636       };
43637     } catch (...) {
43638       {
43639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43640       };
43641     }
43642   }
43643
43644   jresult = (void *)result;
43645   return jresult;
43646 }
43647
43648
43649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43650   void * jresult ;
43651   Dali::Path *arg1 = (Dali::Path *) 0 ;
43652   size_t arg2 ;
43653   Dali::Vector3 *result = 0 ;
43654
43655   arg1 = (Dali::Path *)jarg1;
43656   arg2 = (size_t)jarg2;
43657   {
43658     try {
43659       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43660     } catch (std::out_of_range& e) {
43661       {
43662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43663       };
43664     } catch (std::exception& e) {
43665       {
43666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43667       };
43668     } catch (Dali::DaliException e) {
43669       {
43670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43671       };
43672     } catch (...) {
43673       {
43674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43675       };
43676     }
43677   }
43678
43679   jresult = (void *)result;
43680   return jresult;
43681 }
43682
43683
43684 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43685   unsigned long jresult ;
43686   Dali::Path *arg1 = (Dali::Path *) 0 ;
43687   size_t result;
43688
43689   arg1 = (Dali::Path *)jarg1;
43690   {
43691     try {
43692       result = ((Dali::Path const *)arg1)->GetPointCount();
43693     } catch (std::out_of_range& e) {
43694       {
43695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43696       };
43697     } catch (std::exception& e) {
43698       {
43699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43700       };
43701     } catch (Dali::DaliException e) {
43702       {
43703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43704       };
43705     } catch (...) {
43706       {
43707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43708       };
43709     }
43710   }
43711
43712   jresult = (unsigned long)result;
43713   return jresult;
43714 }
43715
43716
43717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43718   void * jresult ;
43719   float arg1 ;
43720   Dali::TimePeriod *result = 0 ;
43721
43722   arg1 = (float)jarg1;
43723   {
43724     try {
43725       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43726     } catch (std::out_of_range& e) {
43727       {
43728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43729       };
43730     } catch (std::exception& e) {
43731       {
43732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43733       };
43734     } catch (Dali::DaliException e) {
43735       {
43736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43737       };
43738     } catch (...) {
43739       {
43740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43741       };
43742     }
43743   }
43744
43745   jresult = (void *)result;
43746   return jresult;
43747 }
43748
43749
43750 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43751   void * jresult ;
43752   float arg1 ;
43753   float arg2 ;
43754   Dali::TimePeriod *result = 0 ;
43755
43756   arg1 = (float)jarg1;
43757   arg2 = (float)jarg2;
43758   {
43759     try {
43760       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43761     } catch (std::out_of_range& e) {
43762       {
43763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43764       };
43765     } catch (std::exception& e) {
43766       {
43767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43768       };
43769     } catch (Dali::DaliException e) {
43770       {
43771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43772       };
43773     } catch (...) {
43774       {
43775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43776       };
43777     }
43778   }
43779
43780   jresult = (void *)result;
43781   return jresult;
43782 }
43783
43784
43785 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43786   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43787
43788   arg1 = (Dali::TimePeriod *)jarg1;
43789   {
43790     try {
43791       delete arg1;
43792     } catch (std::out_of_range& e) {
43793       {
43794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43795       };
43796     } catch (std::exception& e) {
43797       {
43798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43799       };
43800     } catch (Dali::DaliException e) {
43801       {
43802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43803       };
43804     } catch (...) {
43805       {
43806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43807       };
43808     }
43809   }
43810
43811 }
43812
43813
43814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43815   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43816   float arg2 ;
43817
43818   arg1 = (Dali::TimePeriod *)jarg1;
43819   arg2 = (float)jarg2;
43820   if (arg1) (arg1)->delaySeconds = arg2;
43821 }
43822
43823
43824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43825   float jresult ;
43826   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43827   float result;
43828
43829   arg1 = (Dali::TimePeriod *)jarg1;
43830   result = (float) ((arg1)->delaySeconds);
43831   jresult = result;
43832   return jresult;
43833 }
43834
43835
43836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43837   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43838   float arg2 ;
43839
43840   arg1 = (Dali::TimePeriod *)jarg1;
43841   arg2 = (float)jarg2;
43842   if (arg1) (arg1)->durationSeconds = arg2;
43843 }
43844
43845
43846 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43847   float jresult ;
43848   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43849   float result;
43850
43851   arg1 = (Dali::TimePeriod *)jarg1;
43852   result = (float) ((arg1)->durationSeconds);
43853   jresult = result;
43854   return jresult;
43855 }
43856
43857 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43858   int jresult ;
43859   int result;
43860
43861   result = (int)Dali::LinearConstrainer::Property::VALUE;
43862   jresult = (int)result;
43863   return jresult;
43864 }
43865
43866
43867 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43868   int jresult ;
43869   int result;
43870
43871   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43872   jresult = (int)result;
43873   return jresult;
43874 }
43875
43876
43877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43878   void * jresult ;
43879   Dali::LinearConstrainer::Property *result = 0 ;
43880
43881   {
43882     try {
43883       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43884     } catch (std::out_of_range& e) {
43885       {
43886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43887       };
43888     } catch (std::exception& e) {
43889       {
43890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43891       };
43892     } catch (Dali::DaliException e) {
43893       {
43894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43895       };
43896     } catch (...) {
43897       {
43898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43899       };
43900     }
43901   }
43902
43903   jresult = (void *)result;
43904   return jresult;
43905 }
43906
43907
43908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43909   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43910
43911   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43912   {
43913     try {
43914       delete arg1;
43915     } catch (std::out_of_range& e) {
43916       {
43917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43918       };
43919     } catch (std::exception& e) {
43920       {
43921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43922       };
43923     } catch (Dali::DaliException e) {
43924       {
43925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43926       };
43927     } catch (...) {
43928       {
43929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43930       };
43931     }
43932   }
43933
43934 }
43935
43936
43937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43938   void * jresult ;
43939   Dali::LinearConstrainer result;
43940
43941   {
43942     try {
43943       result = Dali::LinearConstrainer::New();
43944     } catch (std::out_of_range& e) {
43945       {
43946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43947       };
43948     } catch (std::exception& e) {
43949       {
43950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43951       };
43952     } catch (Dali::DaliException e) {
43953       {
43954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43955       };
43956     } catch (...) {
43957       {
43958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43959       };
43960     }
43961   }
43962
43963   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43964   return jresult;
43965 }
43966
43967
43968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43969   void * jresult ;
43970   Dali::BaseHandle arg1 ;
43971   Dali::BaseHandle *argp1 ;
43972   Dali::LinearConstrainer result;
43973
43974   argp1 = (Dali::BaseHandle *)jarg1;
43975   if (!argp1) {
43976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43977     return 0;
43978   }
43979   arg1 = *argp1;
43980   {
43981     try {
43982       result = Dali::LinearConstrainer::DownCast(arg1);
43983     } catch (std::out_of_range& e) {
43984       {
43985         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43986       };
43987     } catch (std::exception& e) {
43988       {
43989         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43990       };
43991     } catch (Dali::DaliException e) {
43992       {
43993         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43994       };
43995     } catch (...) {
43996       {
43997         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43998       };
43999     }
44000   }
44001
44002   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
44003   return jresult;
44004 }
44005
44006
44007 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
44008   void * jresult ;
44009   Dali::LinearConstrainer *result = 0 ;
44010
44011   {
44012     try {
44013       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
44014     } catch (std::out_of_range& e) {
44015       {
44016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44017       };
44018     } catch (std::exception& e) {
44019       {
44020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44021       };
44022     } catch (Dali::DaliException e) {
44023       {
44024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44025       };
44026     } catch (...) {
44027       {
44028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44029       };
44030     }
44031   }
44032
44033   jresult = (void *)result;
44034   return jresult;
44035 }
44036
44037
44038 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
44039   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44040
44041   arg1 = (Dali::LinearConstrainer *)jarg1;
44042   {
44043     try {
44044       delete arg1;
44045     } catch (std::out_of_range& e) {
44046       {
44047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44048       };
44049     } catch (std::exception& e) {
44050       {
44051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44052       };
44053     } catch (Dali::DaliException e) {
44054       {
44055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44056       };
44057     } catch (...) {
44058       {
44059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44060       };
44061     }
44062   }
44063
44064 }
44065
44066
44067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_1(void * jarg1) {
44068   void * jresult ;
44069   Dali::LinearConstrainer *arg1 = 0 ;
44070   Dali::LinearConstrainer *result = 0 ;
44071
44072   arg1 = (Dali::LinearConstrainer *)jarg1;
44073   if (!arg1) {
44074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44075     return 0;
44076   }
44077   {
44078     try {
44079       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
44080     } catch (std::out_of_range& e) {
44081       {
44082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44083       };
44084     } catch (std::exception& e) {
44085       {
44086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44087       };
44088     } catch (Dali::DaliException e) {
44089       {
44090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44091       };
44092     } catch (...) {
44093       {
44094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44095       };
44096     }
44097   }
44098
44099   jresult = (void *)result;
44100   return jresult;
44101 }
44102
44103
44104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
44105   void * jresult ;
44106   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44107   Dali::LinearConstrainer *arg2 = 0 ;
44108   Dali::LinearConstrainer *result = 0 ;
44109
44110   arg1 = (Dali::LinearConstrainer *)jarg1;
44111   arg2 = (Dali::LinearConstrainer *)jarg2;
44112   if (!arg2) {
44113     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
44114     return 0;
44115   }
44116   {
44117     try {
44118       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
44119     } catch (std::out_of_range& e) {
44120       {
44121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44122       };
44123     } catch (std::exception& e) {
44124       {
44125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44126       };
44127     } catch (Dali::DaliException e) {
44128       {
44129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44130       };
44131     } catch (...) {
44132       {
44133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44134       };
44135     }
44136   }
44137
44138   jresult = (void *)result;
44139   return jresult;
44140 }
44141
44142
44143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44144   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44145   SwigValueWrapper< Dali::Property > arg2 ;
44146   SwigValueWrapper< Dali::Property > arg3 ;
44147   Dali::Vector2 *arg4 = 0 ;
44148   Dali::Vector2 *arg5 = 0 ;
44149   Dali::Property *argp2 ;
44150   Dali::Property *argp3 ;
44151
44152   arg1 = (Dali::LinearConstrainer *)jarg1;
44153   argp2 = (Dali::Property *)jarg2;
44154   if (!argp2) {
44155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44156     return ;
44157   }
44158   arg2 = *argp2;
44159   argp3 = (Dali::Property *)jarg3;
44160   if (!argp3) {
44161     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44162     return ;
44163   }
44164   arg3 = *argp3;
44165   arg4 = (Dali::Vector2 *)jarg4;
44166   if (!arg4) {
44167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44168     return ;
44169   }
44170   arg5 = (Dali::Vector2 *)jarg5;
44171   if (!arg5) {
44172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44173     return ;
44174   }
44175   {
44176     try {
44177       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44178     } catch (std::out_of_range& e) {
44179       {
44180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44181       };
44182     } catch (std::exception& e) {
44183       {
44184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44185       };
44186     } catch (Dali::DaliException e) {
44187       {
44188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44189       };
44190     } catch (...) {
44191       {
44192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44193       };
44194     }
44195   }
44196
44197 }
44198
44199
44200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44201   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44202   SwigValueWrapper< Dali::Property > arg2 ;
44203   SwigValueWrapper< Dali::Property > arg3 ;
44204   Dali::Vector2 *arg4 = 0 ;
44205   Dali::Property *argp2 ;
44206   Dali::Property *argp3 ;
44207
44208   arg1 = (Dali::LinearConstrainer *)jarg1;
44209   argp2 = (Dali::Property *)jarg2;
44210   if (!argp2) {
44211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44212     return ;
44213   }
44214   arg2 = *argp2;
44215   argp3 = (Dali::Property *)jarg3;
44216   if (!argp3) {
44217     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44218     return ;
44219   }
44220   arg3 = *argp3;
44221   arg4 = (Dali::Vector2 *)jarg4;
44222   if (!arg4) {
44223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44224     return ;
44225   }
44226   {
44227     try {
44228       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44229     } catch (std::out_of_range& e) {
44230       {
44231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44232       };
44233     } catch (std::exception& e) {
44234       {
44235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44236       };
44237     } catch (Dali::DaliException e) {
44238       {
44239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44240       };
44241     } catch (...) {
44242       {
44243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44244       };
44245     }
44246   }
44247
44248 }
44249
44250
44251 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
44252   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
44253   Dali::Handle *arg2 = 0 ;
44254
44255   arg1 = (Dali::LinearConstrainer *)jarg1;
44256   arg2 = (Dali::Handle *)jarg2;
44257   if (!arg2) {
44258     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44259     return ;
44260   }
44261   {
44262     try {
44263       (arg1)->Remove(*arg2);
44264     } catch (std::out_of_range& e) {
44265       {
44266         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44267       };
44268     } catch (std::exception& e) {
44269       {
44270         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44271       };
44272     } catch (Dali::DaliException e) {
44273       {
44274         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44275       };
44276     } catch (...) {
44277       {
44278         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44279       };
44280     }
44281   }
44282
44283 }
44284
44285
44286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
44287   int jresult ;
44288   int result;
44289
44290   result = (int)Dali::PathConstrainer::Property::FORWARD;
44291   jresult = (int)result;
44292   return jresult;
44293 }
44294
44295
44296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
44297   int jresult ;
44298   int result;
44299
44300   result = (int)Dali::PathConstrainer::Property::POINTS;
44301   jresult = (int)result;
44302   return jresult;
44303 }
44304
44305
44306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
44307   int jresult ;
44308   int result;
44309
44310   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
44311   jresult = (int)result;
44312   return jresult;
44313 }
44314
44315
44316 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
44317   void * jresult ;
44318   Dali::PathConstrainer::Property *result = 0 ;
44319
44320   {
44321     try {
44322       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
44323     } catch (std::out_of_range& e) {
44324       {
44325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44326       };
44327     } catch (std::exception& e) {
44328       {
44329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44330       };
44331     } catch (Dali::DaliException e) {
44332       {
44333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44334       };
44335     } catch (...) {
44336       {
44337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44338       };
44339     }
44340   }
44341
44342   jresult = (void *)result;
44343   return jresult;
44344 }
44345
44346
44347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
44348   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
44349
44350   arg1 = (Dali::PathConstrainer::Property *)jarg1;
44351   {
44352     try {
44353       delete arg1;
44354     } catch (std::out_of_range& e) {
44355       {
44356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44357       };
44358     } catch (std::exception& e) {
44359       {
44360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44361       };
44362     } catch (Dali::DaliException e) {
44363       {
44364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44365       };
44366     } catch (...) {
44367       {
44368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44369       };
44370     }
44371   }
44372
44373 }
44374
44375
44376 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
44377   void * jresult ;
44378   Dali::PathConstrainer result;
44379
44380   {
44381     try {
44382       result = Dali::PathConstrainer::New();
44383     } catch (std::out_of_range& e) {
44384       {
44385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44386       };
44387     } catch (std::exception& e) {
44388       {
44389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44390       };
44391     } catch (Dali::DaliException e) {
44392       {
44393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44394       };
44395     } catch (...) {
44396       {
44397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44398       };
44399     }
44400   }
44401
44402   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44403   return jresult;
44404 }
44405
44406
44407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
44408   void * jresult ;
44409   Dali::BaseHandle arg1 ;
44410   Dali::BaseHandle *argp1 ;
44411   Dali::PathConstrainer result;
44412
44413   argp1 = (Dali::BaseHandle *)jarg1;
44414   if (!argp1) {
44415     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44416     return 0;
44417   }
44418   arg1 = *argp1;
44419   {
44420     try {
44421       result = Dali::PathConstrainer::DownCast(arg1);
44422     } catch (std::out_of_range& e) {
44423       {
44424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44425       };
44426     } catch (std::exception& e) {
44427       {
44428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44429       };
44430     } catch (Dali::DaliException e) {
44431       {
44432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44433       };
44434     } catch (...) {
44435       {
44436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44437       };
44438     }
44439   }
44440
44441   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
44442   return jresult;
44443 }
44444
44445
44446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
44447   void * jresult ;
44448   Dali::PathConstrainer *result = 0 ;
44449
44450   {
44451     try {
44452       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
44453     } catch (std::out_of_range& e) {
44454       {
44455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44456       };
44457     } catch (std::exception& e) {
44458       {
44459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44460       };
44461     } catch (Dali::DaliException e) {
44462       {
44463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44464       };
44465     } catch (...) {
44466       {
44467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44468       };
44469     }
44470   }
44471
44472   jresult = (void *)result;
44473   return jresult;
44474 }
44475
44476
44477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
44478   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44479
44480   arg1 = (Dali::PathConstrainer *)jarg1;
44481   {
44482     try {
44483       delete arg1;
44484     } catch (std::out_of_range& e) {
44485       {
44486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44487       };
44488     } catch (std::exception& e) {
44489       {
44490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44491       };
44492     } catch (Dali::DaliException e) {
44493       {
44494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44495       };
44496     } catch (...) {
44497       {
44498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44499       };
44500     }
44501   }
44502
44503 }
44504
44505
44506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44507   void * jresult ;
44508   Dali::PathConstrainer *arg1 = 0 ;
44509   Dali::PathConstrainer *result = 0 ;
44510
44511   arg1 = (Dali::PathConstrainer *)jarg1;
44512   if (!arg1) {
44513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44514     return 0;
44515   }
44516   {
44517     try {
44518       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44519     } catch (std::out_of_range& e) {
44520       {
44521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44522       };
44523     } catch (std::exception& e) {
44524       {
44525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44526       };
44527     } catch (Dali::DaliException e) {
44528       {
44529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44530       };
44531     } catch (...) {
44532       {
44533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44534       };
44535     }
44536   }
44537
44538   jresult = (void *)result;
44539   return jresult;
44540 }
44541
44542
44543 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44544   void * jresult ;
44545   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44546   Dali::PathConstrainer *arg2 = 0 ;
44547   Dali::PathConstrainer *result = 0 ;
44548
44549   arg1 = (Dali::PathConstrainer *)jarg1;
44550   arg2 = (Dali::PathConstrainer *)jarg2;
44551   if (!arg2) {
44552     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44553     return 0;
44554   }
44555   {
44556     try {
44557       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44558     } catch (std::out_of_range& e) {
44559       {
44560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44561       };
44562     } catch (std::exception& e) {
44563       {
44564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44565       };
44566     } catch (Dali::DaliException e) {
44567       {
44568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44569       };
44570     } catch (...) {
44571       {
44572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44573       };
44574     }
44575   }
44576
44577   jresult = (void *)result;
44578   return jresult;
44579 }
44580
44581
44582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44583   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44584   SwigValueWrapper< Dali::Property > arg2 ;
44585   SwigValueWrapper< Dali::Property > arg3 ;
44586   Dali::Vector2 *arg4 = 0 ;
44587   Dali::Vector2 *arg5 = 0 ;
44588   Dali::Property *argp2 ;
44589   Dali::Property *argp3 ;
44590
44591   arg1 = (Dali::PathConstrainer *)jarg1;
44592   argp2 = (Dali::Property *)jarg2;
44593   if (!argp2) {
44594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44595     return ;
44596   }
44597   arg2 = *argp2;
44598   argp3 = (Dali::Property *)jarg3;
44599   if (!argp3) {
44600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44601     return ;
44602   }
44603   arg3 = *argp3;
44604   arg4 = (Dali::Vector2 *)jarg4;
44605   if (!arg4) {
44606     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44607     return ;
44608   }
44609   arg5 = (Dali::Vector2 *)jarg5;
44610   if (!arg5) {
44611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44612     return ;
44613   }
44614   {
44615     try {
44616       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44617     } catch (std::out_of_range& e) {
44618       {
44619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44620       };
44621     } catch (std::exception& e) {
44622       {
44623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44624       };
44625     } catch (Dali::DaliException e) {
44626       {
44627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44628       };
44629     } catch (...) {
44630       {
44631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44632       };
44633     }
44634   }
44635
44636 }
44637
44638
44639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44640   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44641   SwigValueWrapper< Dali::Property > arg2 ;
44642   SwigValueWrapper< Dali::Property > arg3 ;
44643   Dali::Vector2 *arg4 = 0 ;
44644   Dali::Property *argp2 ;
44645   Dali::Property *argp3 ;
44646
44647   arg1 = (Dali::PathConstrainer *)jarg1;
44648   argp2 = (Dali::Property *)jarg2;
44649   if (!argp2) {
44650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44651     return ;
44652   }
44653   arg2 = *argp2;
44654   argp3 = (Dali::Property *)jarg3;
44655   if (!argp3) {
44656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44657     return ;
44658   }
44659   arg3 = *argp3;
44660   arg4 = (Dali::Vector2 *)jarg4;
44661   if (!arg4) {
44662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44663     return ;
44664   }
44665   {
44666     try {
44667       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44668     } catch (std::out_of_range& e) {
44669       {
44670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44671       };
44672     } catch (std::exception& e) {
44673       {
44674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44675       };
44676     } catch (Dali::DaliException e) {
44677       {
44678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44679       };
44680     } catch (...) {
44681       {
44682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44683       };
44684     }
44685   }
44686
44687 }
44688
44689
44690 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44691   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44692   Dali::Handle *arg2 = 0 ;
44693
44694   arg1 = (Dali::PathConstrainer *)jarg1;
44695   arg2 = (Dali::Handle *)jarg2;
44696   if (!arg2) {
44697     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44698     return ;
44699   }
44700   {
44701     try {
44702       (arg1)->Remove(*arg2);
44703     } catch (std::out_of_range& e) {
44704       {
44705         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44706       };
44707     } catch (std::exception& e) {
44708       {
44709         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44710       };
44711     } catch (Dali::DaliException e) {
44712       {
44713         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44714       };
44715     } catch (...) {
44716       {
44717         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44718       };
44719     }
44720   }
44721
44722 }
44723
44724
44725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44726   int jresult ;
44727   Dali::FittingMode::Type result;
44728
44729   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44730   jresult = (int)result;
44731   return jresult;
44732 }
44733
44734
44735 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44736   int jresult ;
44737   Dali::SamplingMode::Type result;
44738
44739   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44740   jresult = (int)result;
44741   return jresult;
44742 }
44743
44744
44745 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
44746   unsigned int jresult ;
44747   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44748   bool result;
44749
44750   arg1 = (Dali::NativeImageInterface *)jarg1;
44751   {
44752     try {
44753       result = (bool)(arg1)->GlExtensionCreate();
44754     } catch (std::out_of_range& e) {
44755       {
44756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44757       };
44758     } catch (std::exception& e) {
44759       {
44760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44761       };
44762     } catch (Dali::DaliException e) {
44763       {
44764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44765       };
44766     } catch (...) {
44767       {
44768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44769       };
44770     }
44771   }
44772
44773   jresult = result;
44774   return jresult;
44775 }
44776
44777
44778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
44779   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44780
44781   arg1 = (Dali::NativeImageInterface *)jarg1;
44782   {
44783     try {
44784       (arg1)->GlExtensionDestroy();
44785     } catch (std::out_of_range& e) {
44786       {
44787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44788       };
44789     } catch (std::exception& e) {
44790       {
44791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44792       };
44793     } catch (Dali::DaliException e) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44796       };
44797     } catch (...) {
44798       {
44799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44800       };
44801     }
44802   }
44803
44804 }
44805
44806
44807 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44808   unsigned int jresult ;
44809   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44810   unsigned int result;
44811
44812   arg1 = (Dali::NativeImageInterface *)jarg1;
44813   {
44814     try {
44815       result = (unsigned int)(arg1)->TargetTexture();
44816     } catch (std::out_of_range& e) {
44817       {
44818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44819       };
44820     } catch (std::exception& e) {
44821       {
44822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44823       };
44824     } catch (Dali::DaliException e) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44827       };
44828     } catch (...) {
44829       {
44830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44831       };
44832     }
44833   }
44834
44835   jresult = result;
44836   return jresult;
44837 }
44838
44839
44840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44841   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44842
44843   arg1 = (Dali::NativeImageInterface *)jarg1;
44844   {
44845     try {
44846       (arg1)->PrepareTexture();
44847     } catch (std::out_of_range& e) {
44848       {
44849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44850       };
44851     } catch (std::exception& e) {
44852       {
44853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44854       };
44855     } catch (Dali::DaliException e) {
44856       {
44857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44858       };
44859     } catch (...) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44862       };
44863     }
44864   }
44865
44866 }
44867
44868
44869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44870   unsigned int jresult ;
44871   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44872   unsigned int result;
44873
44874   arg1 = (Dali::NativeImageInterface *)jarg1;
44875   {
44876     try {
44877       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44878     } catch (std::out_of_range& e) {
44879       {
44880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44881       };
44882     } catch (std::exception& e) {
44883       {
44884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44885       };
44886     } catch (Dali::DaliException e) {
44887       {
44888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44889       };
44890     } catch (...) {
44891       {
44892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44893       };
44894     }
44895   }
44896
44897   jresult = result;
44898   return jresult;
44899 }
44900
44901
44902 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44903   unsigned int jresult ;
44904   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44905   unsigned int result;
44906
44907   arg1 = (Dali::NativeImageInterface *)jarg1;
44908   {
44909     try {
44910       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44911     } catch (std::out_of_range& e) {
44912       {
44913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44914       };
44915     } catch (std::exception& e) {
44916       {
44917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44918       };
44919     } catch (Dali::DaliException e) {
44920       {
44921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44922       };
44923     } catch (...) {
44924       {
44925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44926       };
44927     }
44928   }
44929
44930   jresult = result;
44931   return jresult;
44932 }
44933
44934
44935 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44936   unsigned int jresult ;
44937   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44938   bool result;
44939
44940   arg1 = (Dali::NativeImageInterface *)jarg1;
44941   {
44942     try {
44943       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44944     } catch (std::out_of_range& e) {
44945       {
44946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44947       };
44948     } catch (std::exception& e) {
44949       {
44950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44951       };
44952     } catch (Dali::DaliException e) {
44953       {
44954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44955       };
44956     } catch (...) {
44957       {
44958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44959       };
44960     }
44961   }
44962
44963   jresult = result;
44964   return jresult;
44965 }
44966
44967 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44968   int jresult ;
44969   int result;
44970
44971   result = (int)Dali::CameraActor::Property::TYPE;
44972   jresult = (int)result;
44973   return jresult;
44974 }
44975
44976
44977 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44978   int jresult ;
44979   int result;
44980
44981   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44982   jresult = (int)result;
44983   return jresult;
44984 }
44985
44986
44987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44988   int jresult ;
44989   int result;
44990
44991   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44992   jresult = (int)result;
44993   return jresult;
44994 }
44995
44996
44997 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44998   int jresult ;
44999   int result;
45000
45001   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
45002   jresult = (int)result;
45003   return jresult;
45004 }
45005
45006
45007 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
45008   int jresult ;
45009   int result;
45010
45011   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
45012   jresult = (int)result;
45013   return jresult;
45014 }
45015
45016
45017 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
45018   int jresult ;
45019   int result;
45020
45021   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
45022   jresult = (int)result;
45023   return jresult;
45024 }
45025
45026
45027 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
45028   int jresult ;
45029   int result;
45030
45031   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
45032   jresult = (int)result;
45033   return jresult;
45034 }
45035
45036
45037 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
45038   int jresult ;
45039   int result;
45040
45041   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
45042   jresult = (int)result;
45043   return jresult;
45044 }
45045
45046
45047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
45048   int jresult ;
45049   int result;
45050
45051   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
45052   jresult = (int)result;
45053   return jresult;
45054 }
45055
45056
45057 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
45058   int jresult ;
45059   int result;
45060
45061   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
45062   jresult = (int)result;
45063   return jresult;
45064 }
45065
45066
45067 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
45068   int jresult ;
45069   int result;
45070
45071   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
45072   jresult = (int)result;
45073   return jresult;
45074 }
45075
45076
45077 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
45078   int jresult ;
45079   int result;
45080
45081   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
45082   jresult = (int)result;
45083   return jresult;
45084 }
45085
45086
45087 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
45088   int jresult ;
45089   int result;
45090
45091   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
45092   jresult = (int)result;
45093   return jresult;
45094 }
45095
45096
45097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
45098   int jresult ;
45099   int result;
45100
45101   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
45102   jresult = (int)result;
45103   return jresult;
45104 }
45105
45106
45107 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
45108   void * jresult ;
45109   Dali::CameraActor::Property *result = 0 ;
45110
45111   {
45112     try {
45113       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
45114     } catch (std::out_of_range& e) {
45115       {
45116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45117       };
45118     } catch (std::exception& e) {
45119       {
45120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45121       };
45122     } catch (Dali::DaliException e) {
45123       {
45124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45125       };
45126     } catch (...) {
45127       {
45128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45129       };
45130     }
45131   }
45132
45133   jresult = (void *)result;
45134   return jresult;
45135 }
45136
45137
45138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
45139   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
45140
45141   arg1 = (Dali::CameraActor::Property *)jarg1;
45142   {
45143     try {
45144       delete arg1;
45145     } catch (std::out_of_range& e) {
45146       {
45147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45148       };
45149     } catch (std::exception& e) {
45150       {
45151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45152       };
45153     } catch (Dali::DaliException e) {
45154       {
45155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45156       };
45157     } catch (...) {
45158       {
45159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45160       };
45161     }
45162   }
45163
45164 }
45165
45166
45167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
45168   void * jresult ;
45169   Dali::CameraActor *result = 0 ;
45170
45171   {
45172     try {
45173       result = (Dali::CameraActor *)new Dali::CameraActor();
45174     } catch (std::out_of_range& e) {
45175       {
45176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45177       };
45178     } catch (std::exception& e) {
45179       {
45180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45181       };
45182     } catch (Dali::DaliException e) {
45183       {
45184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45185       };
45186     } catch (...) {
45187       {
45188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45189       };
45190     }
45191   }
45192
45193   jresult = (void *)result;
45194   return jresult;
45195 }
45196
45197
45198 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
45199   void * jresult ;
45200   Dali::CameraActor result;
45201
45202   {
45203     try {
45204       result = Dali::CameraActor::New();
45205     } catch (std::out_of_range& e) {
45206       {
45207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45208       };
45209     } catch (std::exception& e) {
45210       {
45211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45212       };
45213     } catch (Dali::DaliException e) {
45214       {
45215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45216       };
45217     } catch (...) {
45218       {
45219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45220       };
45221     }
45222   }
45223
45224   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45225   return jresult;
45226 }
45227
45228
45229 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
45230   void * jresult ;
45231   Dali::Size *arg1 = 0 ;
45232   Dali::CameraActor result;
45233
45234   arg1 = (Dali::Size *)jarg1;
45235   if (!arg1) {
45236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45237     return 0;
45238   }
45239   {
45240     try {
45241       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
45242     } catch (std::out_of_range& e) {
45243       {
45244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45245       };
45246     } catch (std::exception& e) {
45247       {
45248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45249       };
45250     } catch (Dali::DaliException e) {
45251       {
45252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45253       };
45254     } catch (...) {
45255       {
45256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45257       };
45258     }
45259   }
45260
45261   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45262   return jresult;
45263 }
45264
45265
45266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
45267   void * jresult ;
45268   Dali::BaseHandle arg1 ;
45269   Dali::BaseHandle *argp1 ;
45270   Dali::CameraActor result;
45271
45272   argp1 = (Dali::BaseHandle *)jarg1;
45273   if (!argp1) {
45274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
45275     return 0;
45276   }
45277   arg1 = *argp1;
45278   {
45279     try {
45280       result = Dali::CameraActor::DownCast(arg1);
45281     } catch (std::out_of_range& e) {
45282       {
45283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45284       };
45285     } catch (std::exception& e) {
45286       {
45287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45288       };
45289     } catch (Dali::DaliException e) {
45290       {
45291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45292       };
45293     } catch (...) {
45294       {
45295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45296       };
45297     }
45298   }
45299
45300   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
45301   return jresult;
45302 }
45303
45304
45305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
45306   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45307
45308   arg1 = (Dali::CameraActor *)jarg1;
45309   {
45310     try {
45311       delete arg1;
45312     } catch (std::out_of_range& e) {
45313       {
45314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45315       };
45316     } catch (std::exception& e) {
45317       {
45318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45319       };
45320     } catch (Dali::DaliException e) {
45321       {
45322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45323       };
45324     } catch (...) {
45325       {
45326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45327       };
45328     }
45329   }
45330
45331 }
45332
45333
45334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
45335   void * jresult ;
45336   Dali::CameraActor *arg1 = 0 ;
45337   Dali::CameraActor *result = 0 ;
45338
45339   arg1 = (Dali::CameraActor *)jarg1;
45340   if (!arg1) {
45341     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45342     return 0;
45343   }
45344   {
45345     try {
45346       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
45347     } catch (std::out_of_range& e) {
45348       {
45349         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45350       };
45351     } catch (std::exception& e) {
45352       {
45353         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45354       };
45355     } catch (Dali::DaliException e) {
45356       {
45357         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45358       };
45359     } catch (...) {
45360       {
45361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45362       };
45363     }
45364   }
45365
45366   jresult = (void *)result;
45367   return jresult;
45368 }
45369
45370
45371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
45372   void * jresult ;
45373   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45374   Dali::CameraActor *arg2 = 0 ;
45375   Dali::CameraActor *result = 0 ;
45376
45377   arg1 = (Dali::CameraActor *)jarg1;
45378   arg2 = (Dali::CameraActor *)jarg2;
45379   if (!arg2) {
45380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
45381     return 0;
45382   }
45383   {
45384     try {
45385       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
45386     } catch (std::out_of_range& e) {
45387       {
45388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45389       };
45390     } catch (std::exception& e) {
45391       {
45392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45393       };
45394     } catch (Dali::DaliException e) {
45395       {
45396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45397       };
45398     } catch (...) {
45399       {
45400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45401       };
45402     }
45403   }
45404
45405   jresult = (void *)result;
45406   return jresult;
45407 }
45408
45409
45410 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
45411   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45412   Dali::Camera::Type arg2 ;
45413
45414   arg1 = (Dali::CameraActor *)jarg1;
45415   arg2 = (Dali::Camera::Type)jarg2;
45416   {
45417     try {
45418       (arg1)->SetType(arg2);
45419     } catch (std::out_of_range& e) {
45420       {
45421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45422       };
45423     } catch (std::exception& e) {
45424       {
45425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45426       };
45427     } catch (Dali::DaliException e) {
45428       {
45429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45430       };
45431     } catch (...) {
45432       {
45433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45434       };
45435     }
45436   }
45437
45438 }
45439
45440
45441 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
45442   int jresult ;
45443   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45444   Dali::Camera::Type result;
45445
45446   arg1 = (Dali::CameraActor *)jarg1;
45447   {
45448     try {
45449       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
45450     } catch (std::out_of_range& e) {
45451       {
45452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45453       };
45454     } catch (std::exception& e) {
45455       {
45456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45457       };
45458     } catch (Dali::DaliException e) {
45459       {
45460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45461       };
45462     } catch (...) {
45463       {
45464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45465       };
45466     }
45467   }
45468
45469   jresult = (int)result;
45470   return jresult;
45471 }
45472
45473
45474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
45475   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45476   Dali::Camera::ProjectionMode arg2 ;
45477
45478   arg1 = (Dali::CameraActor *)jarg1;
45479   arg2 = (Dali::Camera::ProjectionMode)jarg2;
45480   {
45481     try {
45482       (arg1)->SetProjectionMode(arg2);
45483     } catch (std::out_of_range& e) {
45484       {
45485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45486       };
45487     } catch (std::exception& e) {
45488       {
45489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45490       };
45491     } catch (Dali::DaliException e) {
45492       {
45493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45494       };
45495     } catch (...) {
45496       {
45497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45498       };
45499     }
45500   }
45501
45502 }
45503
45504
45505 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45506   int jresult ;
45507   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45508   Dali::Camera::ProjectionMode result;
45509
45510   arg1 = (Dali::CameraActor *)jarg1;
45511   {
45512     try {
45513       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45514     } catch (std::out_of_range& e) {
45515       {
45516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45517       };
45518     } catch (std::exception& e) {
45519       {
45520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45521       };
45522     } catch (Dali::DaliException e) {
45523       {
45524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45525       };
45526     } catch (...) {
45527       {
45528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45529       };
45530     }
45531   }
45532
45533   jresult = (int)result;
45534   return jresult;
45535 }
45536
45537
45538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45539   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45540   float arg2 ;
45541
45542   arg1 = (Dali::CameraActor *)jarg1;
45543   arg2 = (float)jarg2;
45544   {
45545     try {
45546       (arg1)->SetFieldOfView(arg2);
45547     } catch (std::out_of_range& e) {
45548       {
45549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45550       };
45551     } catch (std::exception& e) {
45552       {
45553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45554       };
45555     } catch (Dali::DaliException e) {
45556       {
45557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45558       };
45559     } catch (...) {
45560       {
45561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45562       };
45563     }
45564   }
45565
45566 }
45567
45568
45569 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45570   float jresult ;
45571   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45572   float result;
45573
45574   arg1 = (Dali::CameraActor *)jarg1;
45575   {
45576     try {
45577       result = (float)(arg1)->GetFieldOfView();
45578     } catch (std::out_of_range& e) {
45579       {
45580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45581       };
45582     } catch (std::exception& e) {
45583       {
45584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45585       };
45586     } catch (Dali::DaliException e) {
45587       {
45588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45589       };
45590     } catch (...) {
45591       {
45592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45593       };
45594     }
45595   }
45596
45597   jresult = result;
45598   return jresult;
45599 }
45600
45601
45602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45603   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45604   float arg2 ;
45605
45606   arg1 = (Dali::CameraActor *)jarg1;
45607   arg2 = (float)jarg2;
45608   {
45609     try {
45610       (arg1)->SetAspectRatio(arg2);
45611     } catch (std::out_of_range& e) {
45612       {
45613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45614       };
45615     } catch (std::exception& e) {
45616       {
45617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45618       };
45619     } catch (Dali::DaliException e) {
45620       {
45621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45622       };
45623     } catch (...) {
45624       {
45625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45626       };
45627     }
45628   }
45629
45630 }
45631
45632
45633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45634   float jresult ;
45635   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45636   float result;
45637
45638   arg1 = (Dali::CameraActor *)jarg1;
45639   {
45640     try {
45641       result = (float)(arg1)->GetAspectRatio();
45642     } catch (std::out_of_range& e) {
45643       {
45644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45645       };
45646     } catch (std::exception& e) {
45647       {
45648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45649       };
45650     } catch (Dali::DaliException e) {
45651       {
45652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45653       };
45654     } catch (...) {
45655       {
45656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45657       };
45658     }
45659   }
45660
45661   jresult = result;
45662   return jresult;
45663 }
45664
45665
45666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45667   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45668   float arg2 ;
45669
45670   arg1 = (Dali::CameraActor *)jarg1;
45671   arg2 = (float)jarg2;
45672   {
45673     try {
45674       (arg1)->SetNearClippingPlane(arg2);
45675     } catch (std::out_of_range& e) {
45676       {
45677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45678       };
45679     } catch (std::exception& e) {
45680       {
45681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45682       };
45683     } catch (Dali::DaliException e) {
45684       {
45685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45686       };
45687     } catch (...) {
45688       {
45689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45690       };
45691     }
45692   }
45693
45694 }
45695
45696
45697 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45698   float jresult ;
45699   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45700   float result;
45701
45702   arg1 = (Dali::CameraActor *)jarg1;
45703   {
45704     try {
45705       result = (float)(arg1)->GetNearClippingPlane();
45706     } catch (std::out_of_range& e) {
45707       {
45708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45709       };
45710     } catch (std::exception& e) {
45711       {
45712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45713       };
45714     } catch (Dali::DaliException e) {
45715       {
45716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45717       };
45718     } catch (...) {
45719       {
45720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45721       };
45722     }
45723   }
45724
45725   jresult = result;
45726   return jresult;
45727 }
45728
45729
45730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45731   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45732   float arg2 ;
45733
45734   arg1 = (Dali::CameraActor *)jarg1;
45735   arg2 = (float)jarg2;
45736   {
45737     try {
45738       (arg1)->SetFarClippingPlane(arg2);
45739     } catch (std::out_of_range& e) {
45740       {
45741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45742       };
45743     } catch (std::exception& e) {
45744       {
45745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45746       };
45747     } catch (Dali::DaliException e) {
45748       {
45749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45750       };
45751     } catch (...) {
45752       {
45753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45754       };
45755     }
45756   }
45757
45758 }
45759
45760
45761 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45762   float jresult ;
45763   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45764   float result;
45765
45766   arg1 = (Dali::CameraActor *)jarg1;
45767   {
45768     try {
45769       result = (float)(arg1)->GetFarClippingPlane();
45770     } catch (std::out_of_range& e) {
45771       {
45772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45773       };
45774     } catch (std::exception& e) {
45775       {
45776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45777       };
45778     } catch (Dali::DaliException e) {
45779       {
45780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45781       };
45782     } catch (...) {
45783       {
45784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45785       };
45786     }
45787   }
45788
45789   jresult = result;
45790   return jresult;
45791 }
45792
45793
45794 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45795   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45796   Dali::Vector3 *arg2 = 0 ;
45797
45798   arg1 = (Dali::CameraActor *)jarg1;
45799   arg2 = (Dali::Vector3 *)jarg2;
45800   if (!arg2) {
45801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45802     return ;
45803   }
45804   {
45805     try {
45806       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45807     } catch (std::out_of_range& e) {
45808       {
45809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45810       };
45811     } catch (std::exception& e) {
45812       {
45813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45814       };
45815     } catch (Dali::DaliException e) {
45816       {
45817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45818       };
45819     } catch (...) {
45820       {
45821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45822       };
45823     }
45824   }
45825
45826 }
45827
45828
45829 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45830   void * jresult ;
45831   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45832   Dali::Vector3 result;
45833
45834   arg1 = (Dali::CameraActor *)jarg1;
45835   {
45836     try {
45837       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45838     } catch (std::out_of_range& e) {
45839       {
45840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45841       };
45842     } catch (std::exception& e) {
45843       {
45844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45845       };
45846     } catch (Dali::DaliException e) {
45847       {
45848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45849       };
45850     } catch (...) {
45851       {
45852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45853       };
45854     }
45855   }
45856
45857   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45858   return jresult;
45859 }
45860
45861
45862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45863   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45864   bool arg2 ;
45865
45866   arg1 = (Dali::CameraActor *)jarg1;
45867   arg2 = jarg2 ? true : false;
45868   {
45869     try {
45870       (arg1)->SetInvertYAxis(arg2);
45871     } catch (std::out_of_range& e) {
45872       {
45873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45874       };
45875     } catch (std::exception& e) {
45876       {
45877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45878       };
45879     } catch (Dali::DaliException e) {
45880       {
45881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45882       };
45883     } catch (...) {
45884       {
45885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45886       };
45887     }
45888   }
45889
45890 }
45891
45892
45893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45894   unsigned int jresult ;
45895   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45896   bool result;
45897
45898   arg1 = (Dali::CameraActor *)jarg1;
45899   {
45900     try {
45901       result = (bool)(arg1)->GetInvertYAxis();
45902     } catch (std::out_of_range& e) {
45903       {
45904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45905       };
45906     } catch (std::exception& e) {
45907       {
45908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45909       };
45910     } catch (Dali::DaliException e) {
45911       {
45912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45913       };
45914     } catch (...) {
45915       {
45916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45917       };
45918     }
45919   }
45920
45921   jresult = result;
45922   return jresult;
45923 }
45924
45925
45926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45927   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45928   Dali::Size *arg2 = 0 ;
45929
45930   arg1 = (Dali::CameraActor *)jarg1;
45931   arg2 = (Dali::Size *)jarg2;
45932   if (!arg2) {
45933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45934     return ;
45935   }
45936   {
45937     try {
45938       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45939     } catch (std::out_of_range& e) {
45940       {
45941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45942       };
45943     } catch (std::exception& e) {
45944       {
45945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45946       };
45947     } catch (Dali::DaliException e) {
45948       {
45949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45950       };
45951     } catch (...) {
45952       {
45953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45954       };
45955     }
45956   }
45957
45958 }
45959
45960
45961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45962   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45963   Dali::Size *arg2 = 0 ;
45964
45965   arg1 = (Dali::CameraActor *)jarg1;
45966   arg2 = (Dali::Size *)jarg2;
45967   if (!arg2) {
45968     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45969     return ;
45970   }
45971   {
45972     try {
45973       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45974     } catch (std::out_of_range& e) {
45975       {
45976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45977       };
45978     } catch (std::exception& e) {
45979       {
45980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45981       };
45982     } catch (Dali::DaliException e) {
45983       {
45984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45985       };
45986     } catch (...) {
45987       {
45988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45989       };
45990     }
45991   }
45992
45993 }
45994
45995
45996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45997   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45998   float arg2 ;
45999   float arg3 ;
46000   float arg4 ;
46001   float arg5 ;
46002   float arg6 ;
46003   float arg7 ;
46004
46005   arg1 = (Dali::CameraActor *)jarg1;
46006   arg2 = (float)jarg2;
46007   arg3 = (float)jarg3;
46008   arg4 = (float)jarg4;
46009   arg5 = (float)jarg5;
46010   arg6 = (float)jarg6;
46011   arg7 = (float)jarg7;
46012   {
46013     try {
46014       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
46015     } catch (std::out_of_range& e) {
46016       {
46017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46018       };
46019     } catch (std::exception& e) {
46020       {
46021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46022       };
46023     } catch (Dali::DaliException e) {
46024       {
46025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46026       };
46027     } catch (...) {
46028       {
46029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46030       };
46031     }
46032   }
46033
46034 }
46035
46036
46037 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
46038   void * jresult ;
46039   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46040
46041   {
46042     try {
46043       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
46044     } catch (std::out_of_range& e) {
46045       {
46046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46047       };
46048     } catch (std::exception& e) {
46049       {
46050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46051       };
46052     } catch (Dali::DaliException e) {
46053       {
46054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46055       };
46056     } catch (...) {
46057       {
46058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46059       };
46060     }
46061   }
46062
46063   jresult = (void *)result;
46064   return jresult;
46065 }
46066
46067
46068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
46069   void * jresult ;
46070   std::string arg1 ;
46071   Dali::Property::Value arg2 ;
46072   Dali::Property::Value *argp2 ;
46073   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46074
46075   if (!jarg1) {
46076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46077     return 0;
46078   }
46079   (&arg1)->assign(jarg1);
46080   argp2 = (Dali::Property::Value *)jarg2;
46081   if (!argp2) {
46082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
46083     return 0;
46084   }
46085   arg2 = *argp2;
46086   {
46087     try {
46088       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
46089     } catch (std::out_of_range& e) {
46090       {
46091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46092       };
46093     } catch (std::exception& e) {
46094       {
46095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46096       };
46097     } catch (Dali::DaliException e) {
46098       {
46099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46100       };
46101     } catch (...) {
46102       {
46103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46104       };
46105     }
46106   }
46107
46108   jresult = (void *)result;
46109   return jresult;
46110 }
46111
46112
46113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
46114   void * jresult ;
46115   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
46116   std::pair< std::string,Dali::Property::Value > *result = 0 ;
46117
46118   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46119   if (!arg1) {
46120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
46121     return 0;
46122   }
46123   {
46124     try {
46125       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);
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 = (void *)result;
46146   return jresult;
46147 }
46148
46149
46150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
46151   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46152   std::string *arg2 = 0 ;
46153
46154   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46155   if (!jarg2) {
46156     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
46157     return ;
46158   }
46159   std::string arg2_str(jarg2);
46160   arg2 = &arg2_str;
46161   if (arg1) (arg1)->first = *arg2;
46162
46163   //argout typemap for const std::string&
46164
46165 }
46166
46167
46168 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
46169   char * jresult ;
46170   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46171   std::string *result = 0 ;
46172
46173   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46174   result = (std::string *) & ((arg1)->first);
46175   jresult = SWIG_csharp_string_callback(result->c_str());
46176   return jresult;
46177 }
46178
46179
46180 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
46181   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46182   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
46183
46184   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46185   arg2 = (Dali::Property::Value *)jarg2;
46186   if (arg1) (arg1)->second = *arg2;
46187 }
46188
46189
46190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
46191   void * jresult ;
46192   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46193   Dali::Property::Value *result = 0 ;
46194
46195   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46196   result = (Dali::Property::Value *)& ((arg1)->second);
46197   jresult = (void *)result;
46198   return jresult;
46199 }
46200
46201
46202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
46203   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
46204
46205   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
46206   {
46207     try {
46208       delete arg1;
46209     } catch (std::out_of_range& e) {
46210       {
46211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46212       };
46213     } catch (std::exception& e) {
46214       {
46215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46216       };
46217     } catch (Dali::DaliException e) {
46218       {
46219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46220       };
46221     } catch (...) {
46222       {
46223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46224       };
46225     }
46226   }
46227
46228 }
46229
46230
46231 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
46232   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46233
46234   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46235   {
46236     try {
46237       (arg1)->clear();
46238     } catch (std::out_of_range& e) {
46239       {
46240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46241       };
46242     } catch (std::exception& e) {
46243       {
46244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46245       };
46246     } catch (Dali::DaliException e) {
46247       {
46248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46249       };
46250     } catch (...) {
46251       {
46252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46253       };
46254     }
46255   }
46256
46257 }
46258
46259
46260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
46261   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46262   Dali::TouchPoint *arg2 = 0 ;
46263
46264   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46265   arg2 = (Dali::TouchPoint *)jarg2;
46266   if (!arg2) {
46267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46268     return ;
46269   }
46270   {
46271     try {
46272       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
46273     } catch (std::out_of_range& e) {
46274       {
46275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46276       };
46277     } catch (std::exception& e) {
46278       {
46279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46280       };
46281     } catch (Dali::DaliException e) {
46282       {
46283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46284       };
46285     } catch (...) {
46286       {
46287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46288       };
46289     }
46290   }
46291
46292 }
46293
46294
46295 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
46296   unsigned long jresult ;
46297   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46298   std::vector< Dali::TouchPoint >::size_type result;
46299
46300   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46301   {
46302     try {
46303       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
46304     } catch (std::out_of_range& e) {
46305       {
46306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46307       };
46308     } catch (std::exception& e) {
46309       {
46310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46311       };
46312     } catch (Dali::DaliException e) {
46313       {
46314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46315       };
46316     } catch (...) {
46317       {
46318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46319       };
46320     }
46321   }
46322
46323   jresult = (unsigned long)result;
46324   return jresult;
46325 }
46326
46327
46328 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
46329   unsigned long jresult ;
46330   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46331   std::vector< Dali::TouchPoint >::size_type result;
46332
46333   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46334   {
46335     try {
46336       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
46337     } catch (std::out_of_range& e) {
46338       {
46339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46340       };
46341     } catch (std::exception& e) {
46342       {
46343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46344       };
46345     } catch (Dali::DaliException e) {
46346       {
46347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46348       };
46349     } catch (...) {
46350       {
46351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46352       };
46353     }
46354   }
46355
46356   jresult = (unsigned long)result;
46357   return jresult;
46358 }
46359
46360
46361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
46362   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46363   std::vector< Dali::TouchPoint >::size_type arg2 ;
46364
46365   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46366   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
46367   {
46368     try {
46369       (arg1)->reserve(arg2);
46370     } catch (std::out_of_range& e) {
46371       {
46372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46373       };
46374     } catch (std::exception& e) {
46375       {
46376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46377       };
46378     } catch (Dali::DaliException e) {
46379       {
46380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46381       };
46382     } catch (...) {
46383       {
46384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46385       };
46386     }
46387   }
46388
46389 }
46390
46391
46392 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
46393   void * jresult ;
46394   std::vector< Dali::TouchPoint > *result = 0 ;
46395
46396   {
46397     try {
46398       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
46399     } catch (std::out_of_range& e) {
46400       {
46401         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46402       };
46403     } catch (std::exception& e) {
46404       {
46405         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46406       };
46407     } catch (Dali::DaliException e) {
46408       {
46409         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46410       };
46411     } catch (...) {
46412       {
46413         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46414       };
46415     }
46416   }
46417
46418   jresult = (void *)result;
46419   return jresult;
46420 }
46421
46422
46423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
46424   void * jresult ;
46425   std::vector< Dali::TouchPoint > *arg1 = 0 ;
46426   std::vector< Dali::TouchPoint > *result = 0 ;
46427
46428   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46429   if (!arg1) {
46430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46431     return 0;
46432   }
46433   {
46434     try {
46435       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
46436     } catch (std::out_of_range& e) {
46437       {
46438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46439       };
46440     } catch (std::exception& e) {
46441       {
46442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46443       };
46444     } catch (Dali::DaliException e) {
46445       {
46446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46447       };
46448     } catch (...) {
46449       {
46450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46451       };
46452     }
46453   }
46454
46455   jresult = (void *)result;
46456   return jresult;
46457 }
46458
46459
46460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
46461   void * jresult ;
46462   int arg1 ;
46463   std::vector< Dali::TouchPoint > *result = 0 ;
46464
46465   arg1 = (int)jarg1;
46466   {
46467     try {
46468       try {
46469         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
46470       }
46471       catch(std::out_of_range &_e) {
46472         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46473         return 0;
46474       }
46475
46476     } catch (std::out_of_range& e) {
46477       {
46478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46479       };
46480     } catch (std::exception& e) {
46481       {
46482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46483       };
46484     } catch (Dali::DaliException e) {
46485       {
46486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46487       };
46488     } catch (...) {
46489       {
46490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46491       };
46492     }
46493   }
46494
46495   jresult = (void *)result;
46496   return jresult;
46497 }
46498
46499
46500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46501   void * jresult ;
46502   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46503   int arg2 ;
46504   SwigValueWrapper< Dali::TouchPoint > result;
46505
46506   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46507   arg2 = (int)jarg2;
46508   {
46509     try {
46510       try {
46511         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46512       }
46513       catch(std::out_of_range &_e) {
46514         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46515         return 0;
46516       }
46517
46518     } catch (std::out_of_range& e) {
46519       {
46520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46521       };
46522     } catch (std::exception& e) {
46523       {
46524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46525       };
46526     } catch (Dali::DaliException e) {
46527       {
46528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46529       };
46530     } catch (...) {
46531       {
46532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46533       };
46534     }
46535   }
46536
46537   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46538   return jresult;
46539 }
46540
46541
46542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46543   void * jresult ;
46544   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46545   int arg2 ;
46546   Dali::TouchPoint *result = 0 ;
46547
46548   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46549   arg2 = (int)jarg2;
46550   {
46551     try {
46552       try {
46553         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46554       }
46555       catch(std::out_of_range &_e) {
46556         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46557         return 0;
46558       }
46559
46560     } catch (std::out_of_range& e) {
46561       {
46562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46563       };
46564     } catch (std::exception& e) {
46565       {
46566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46567       };
46568     } catch (Dali::DaliException e) {
46569       {
46570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46571       };
46572     } catch (...) {
46573       {
46574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46575       };
46576     }
46577   }
46578
46579   jresult = (void *)result;
46580   return jresult;
46581 }
46582
46583
46584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46585   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46586   int arg2 ;
46587   Dali::TouchPoint *arg3 = 0 ;
46588
46589   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46590   arg2 = (int)jarg2;
46591   arg3 = (Dali::TouchPoint *)jarg3;
46592   if (!arg3) {
46593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46594     return ;
46595   }
46596   {
46597     try {
46598       try {
46599         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46600       }
46601       catch(std::out_of_range &_e) {
46602         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46603         return ;
46604       }
46605
46606     } catch (std::out_of_range& e) {
46607       {
46608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46609       };
46610     } catch (std::exception& e) {
46611       {
46612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46613       };
46614     } catch (Dali::DaliException e) {
46615       {
46616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46617       };
46618     } catch (...) {
46619       {
46620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46621       };
46622     }
46623   }
46624
46625 }
46626
46627
46628 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46629   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46630   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46631
46632   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46633   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46634   if (!arg2) {
46635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46636     return ;
46637   }
46638   {
46639     try {
46640       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46641     } catch (std::out_of_range& e) {
46642       {
46643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46644       };
46645     } catch (std::exception& e) {
46646       {
46647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46648       };
46649     } catch (Dali::DaliException e) {
46650       {
46651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46652       };
46653     } catch (...) {
46654       {
46655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46656       };
46657     }
46658   }
46659
46660 }
46661
46662
46663 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46664   void * jresult ;
46665   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46666   int arg2 ;
46667   int arg3 ;
46668   std::vector< Dali::TouchPoint > *result = 0 ;
46669
46670   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46671   arg2 = (int)jarg2;
46672   arg3 = (int)jarg3;
46673   {
46674     try {
46675       try {
46676         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46677       }
46678       catch(std::out_of_range &_e) {
46679         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46680         return 0;
46681       }
46682       catch(std::invalid_argument &_e) {
46683         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46684         return 0;
46685       }
46686
46687     } catch (std::out_of_range& e) {
46688       {
46689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46690       };
46691     } catch (std::exception& e) {
46692       {
46693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46694       };
46695     } catch (Dali::DaliException e) {
46696       {
46697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46698       };
46699     } catch (...) {
46700       {
46701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46702       };
46703     }
46704   }
46705
46706   jresult = (void *)result;
46707   return jresult;
46708 }
46709
46710
46711 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46712   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46713   int arg2 ;
46714   Dali::TouchPoint *arg3 = 0 ;
46715
46716   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46717   arg2 = (int)jarg2;
46718   arg3 = (Dali::TouchPoint *)jarg3;
46719   if (!arg3) {
46720     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46721     return ;
46722   }
46723   {
46724     try {
46725       try {
46726         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46727       }
46728       catch(std::out_of_range &_e) {
46729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46730         return ;
46731       }
46732
46733     } catch (std::out_of_range& e) {
46734       {
46735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46736       };
46737     } catch (std::exception& e) {
46738       {
46739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46740       };
46741     } catch (Dali::DaliException e) {
46742       {
46743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46744       };
46745     } catch (...) {
46746       {
46747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46748       };
46749     }
46750   }
46751
46752 }
46753
46754
46755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46756   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46757   int arg2 ;
46758   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46759
46760   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46761   arg2 = (int)jarg2;
46762   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46763   if (!arg3) {
46764     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46765     return ;
46766   }
46767   {
46768     try {
46769       try {
46770         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46771       }
46772       catch(std::out_of_range &_e) {
46773         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46774         return ;
46775       }
46776
46777     } catch (std::out_of_range& e) {
46778       {
46779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46780       };
46781     } catch (std::exception& e) {
46782       {
46783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46784       };
46785     } catch (Dali::DaliException e) {
46786       {
46787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46788       };
46789     } catch (...) {
46790       {
46791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46792       };
46793     }
46794   }
46795
46796 }
46797
46798
46799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46800   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46801   int arg2 ;
46802
46803   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46804   arg2 = (int)jarg2;
46805   {
46806     try {
46807       try {
46808         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46809       }
46810       catch(std::out_of_range &_e) {
46811         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46812         return ;
46813       }
46814
46815     } catch (std::out_of_range& e) {
46816       {
46817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46818       };
46819     } catch (std::exception& e) {
46820       {
46821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46822       };
46823     } catch (Dali::DaliException e) {
46824       {
46825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46826       };
46827     } catch (...) {
46828       {
46829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46830       };
46831     }
46832   }
46833
46834 }
46835
46836
46837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46838   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46839   int arg2 ;
46840   int arg3 ;
46841
46842   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46843   arg2 = (int)jarg2;
46844   arg3 = (int)jarg3;
46845   {
46846     try {
46847       try {
46848         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46849       }
46850       catch(std::out_of_range &_e) {
46851         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46852         return ;
46853       }
46854       catch(std::invalid_argument &_e) {
46855         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46856         return ;
46857       }
46858
46859     } catch (std::out_of_range& e) {
46860       {
46861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46862       };
46863     } catch (std::exception& e) {
46864       {
46865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46866       };
46867     } catch (Dali::DaliException e) {
46868       {
46869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46870       };
46871     } catch (...) {
46872       {
46873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46874       };
46875     }
46876   }
46877
46878 }
46879
46880
46881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46882   void * jresult ;
46883   Dali::TouchPoint *arg1 = 0 ;
46884   int arg2 ;
46885   std::vector< Dali::TouchPoint > *result = 0 ;
46886
46887   arg1 = (Dali::TouchPoint *)jarg1;
46888   if (!arg1) {
46889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46890     return 0;
46891   }
46892   arg2 = (int)jarg2;
46893   {
46894     try {
46895       try {
46896         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46897       }
46898       catch(std::out_of_range &_e) {
46899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46900         return 0;
46901       }
46902
46903     } catch (std::out_of_range& e) {
46904       {
46905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46906       };
46907     } catch (std::exception& e) {
46908       {
46909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46910       };
46911     } catch (Dali::DaliException e) {
46912       {
46913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46914       };
46915     } catch (...) {
46916       {
46917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46918       };
46919     }
46920   }
46921
46922   jresult = (void *)result;
46923   return jresult;
46924 }
46925
46926
46927 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46928   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46929
46930   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46931   {
46932     try {
46933       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46934     } catch (std::out_of_range& e) {
46935       {
46936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46937       };
46938     } catch (std::exception& e) {
46939       {
46940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46941       };
46942     } catch (Dali::DaliException e) {
46943       {
46944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46945       };
46946     } catch (...) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46949       };
46950     }
46951   }
46952
46953 }
46954
46955
46956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46957   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46958   int arg2 ;
46959   int arg3 ;
46960
46961   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46962   arg2 = (int)jarg2;
46963   arg3 = (int)jarg3;
46964   {
46965     try {
46966       try {
46967         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46968       }
46969       catch(std::out_of_range &_e) {
46970         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46971         return ;
46972       }
46973       catch(std::invalid_argument &_e) {
46974         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46975         return ;
46976       }
46977
46978     } catch (std::out_of_range& e) {
46979       {
46980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46981       };
46982     } catch (std::exception& e) {
46983       {
46984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46985       };
46986     } catch (Dali::DaliException e) {
46987       {
46988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46989       };
46990     } catch (...) {
46991       {
46992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46993       };
46994     }
46995   }
46996
46997 }
46998
46999
47000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
47001   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47002   int arg2 ;
47003   std::vector< Dali::TouchPoint > *arg3 = 0 ;
47004
47005   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47006   arg2 = (int)jarg2;
47007   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
47008   if (!arg3) {
47009     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
47010     return ;
47011   }
47012   {
47013     try {
47014       try {
47015         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
47016       }
47017       catch(std::out_of_range &_e) {
47018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
47019         return ;
47020       }
47021
47022     } catch (std::out_of_range& e) {
47023       {
47024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47025       };
47026     } catch (std::exception& e) {
47027       {
47028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47029       };
47030     } catch (Dali::DaliException e) {
47031       {
47032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47033       };
47034     } catch (...) {
47035       {
47036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47037       };
47038     }
47039   }
47040
47041 }
47042
47043
47044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
47045   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
47046
47047   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
47048   {
47049     try {
47050       delete arg1;
47051     } catch (std::out_of_range& e) {
47052       {
47053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47054       };
47055     } catch (std::exception& e) {
47056       {
47057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47058       };
47059     } catch (Dali::DaliException e) {
47060       {
47061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47062       };
47063     } catch (...) {
47064       {
47065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47066       };
47067     }
47068   }
47069
47070 }
47071
47072
47073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
47074   void * jresult ;
47075   Dali::Rect< int > *result = 0 ;
47076
47077   {
47078     try {
47079       result = (Dali::Rect< int > *)new Dali::Rect< int >();
47080     } catch (std::out_of_range& e) {
47081       {
47082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47083       };
47084     } catch (std::exception& e) {
47085       {
47086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47087       };
47088     } catch (Dali::DaliException e) {
47089       {
47090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47091       };
47092     } catch (...) {
47093       {
47094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47095       };
47096     }
47097   }
47098
47099   jresult = (void *)result;
47100   return jresult;
47101 }
47102
47103
47104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
47105   void * jresult ;
47106   int arg1 ;
47107   int arg2 ;
47108   int arg3 ;
47109   int arg4 ;
47110   Dali::Rect< int > *result = 0 ;
47111
47112   arg1 = (int)jarg1;
47113   arg2 = (int)jarg2;
47114   arg3 = (int)jarg3;
47115   arg4 = (int)jarg4;
47116   {
47117     try {
47118       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
47119     } catch (std::out_of_range& e) {
47120       {
47121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47122       };
47123     } catch (std::exception& e) {
47124       {
47125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47126       };
47127     } catch (Dali::DaliException e) {
47128       {
47129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47130       };
47131     } catch (...) {
47132       {
47133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47134       };
47135     }
47136   }
47137
47138   jresult = (void *)result;
47139   return jresult;
47140 }
47141
47142
47143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
47144   void * jresult ;
47145   Dali::Rect< int > *arg1 = 0 ;
47146   Dali::Rect< int > *result = 0 ;
47147
47148   arg1 = (Dali::Rect< int > *)jarg1;
47149   if (!arg1) {
47150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47151     return 0;
47152   }
47153   {
47154     try {
47155       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
47156     } catch (std::out_of_range& e) {
47157       {
47158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47159       };
47160     } catch (std::exception& e) {
47161       {
47162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47163       };
47164     } catch (Dali::DaliException e) {
47165       {
47166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47167       };
47168     } catch (...) {
47169       {
47170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47171       };
47172     }
47173   }
47174
47175   jresult = (void *)result;
47176   return jresult;
47177 }
47178
47179
47180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
47181   void * jresult ;
47182   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47183   Dali::Rect< int > *arg2 = 0 ;
47184   Dali::Rect< int > *result = 0 ;
47185
47186   arg1 = (Dali::Rect< int > *)jarg1;
47187   arg2 = (Dali::Rect< int > *)jarg2;
47188   if (!arg2) {
47189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47190     return 0;
47191   }
47192   {
47193     try {
47194       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
47195     } catch (std::out_of_range& e) {
47196       {
47197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47198       };
47199     } catch (std::exception& e) {
47200       {
47201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47202       };
47203     } catch (Dali::DaliException e) {
47204       {
47205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47206       };
47207     } catch (...) {
47208       {
47209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47210       };
47211     }
47212   }
47213
47214   jresult = (void *)result;
47215   return jresult;
47216 }
47217
47218
47219 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
47220   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47221   int arg2 ;
47222   int arg3 ;
47223   int arg4 ;
47224   int arg5 ;
47225
47226   arg1 = (Dali::Rect< int > *)jarg1;
47227   arg2 = (int)jarg2;
47228   arg3 = (int)jarg3;
47229   arg4 = (int)jarg4;
47230   arg5 = (int)jarg5;
47231   {
47232     try {
47233       (arg1)->Set(arg2,arg3,arg4,arg5);
47234     } catch (std::out_of_range& e) {
47235       {
47236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47237       };
47238     } catch (std::exception& e) {
47239       {
47240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47241       };
47242     } catch (Dali::DaliException e) {
47243       {
47244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47245       };
47246     } catch (...) {
47247       {
47248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47249       };
47250     }
47251   }
47252
47253 }
47254
47255
47256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
47257   unsigned int jresult ;
47258   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47259   bool result;
47260
47261   arg1 = (Dali::Rect< int > *)jarg1;
47262   {
47263     try {
47264       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
47265     } catch (std::out_of_range& e) {
47266       {
47267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47268       };
47269     } catch (std::exception& e) {
47270       {
47271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47272       };
47273     } catch (Dali::DaliException e) {
47274       {
47275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47276       };
47277     } catch (...) {
47278       {
47279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47280       };
47281     }
47282   }
47283
47284   jresult = result;
47285   return jresult;
47286 }
47287
47288
47289 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
47290   int jresult ;
47291   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47292   int result;
47293
47294   arg1 = (Dali::Rect< int > *)jarg1;
47295   {
47296     try {
47297       result = (int)((Dali::Rect< int > const *)arg1)->Left();
47298     } catch (std::out_of_range& e) {
47299       {
47300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47301       };
47302     } catch (std::exception& e) {
47303       {
47304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47305       };
47306     } catch (Dali::DaliException e) {
47307       {
47308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47309       };
47310     } catch (...) {
47311       {
47312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47313       };
47314     }
47315   }
47316
47317   jresult = result;
47318   return jresult;
47319 }
47320
47321
47322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
47323   int jresult ;
47324   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47325   int result;
47326
47327   arg1 = (Dali::Rect< int > *)jarg1;
47328   {
47329     try {
47330       result = (int)((Dali::Rect< int > const *)arg1)->Right();
47331     } catch (std::out_of_range& e) {
47332       {
47333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47334       };
47335     } catch (std::exception& e) {
47336       {
47337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47338       };
47339     } catch (Dali::DaliException e) {
47340       {
47341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47342       };
47343     } catch (...) {
47344       {
47345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47346       };
47347     }
47348   }
47349
47350   jresult = result;
47351   return jresult;
47352 }
47353
47354
47355 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
47356   int jresult ;
47357   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47358   int result;
47359
47360   arg1 = (Dali::Rect< int > *)jarg1;
47361   {
47362     try {
47363       result = (int)((Dali::Rect< int > const *)arg1)->Top();
47364     } catch (std::out_of_range& e) {
47365       {
47366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47367       };
47368     } catch (std::exception& e) {
47369       {
47370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47371       };
47372     } catch (Dali::DaliException e) {
47373       {
47374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47375       };
47376     } catch (...) {
47377       {
47378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47379       };
47380     }
47381   }
47382
47383   jresult = result;
47384   return jresult;
47385 }
47386
47387
47388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
47389   int jresult ;
47390   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47391   int result;
47392
47393   arg1 = (Dali::Rect< int > *)jarg1;
47394   {
47395     try {
47396       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
47397     } catch (std::out_of_range& e) {
47398       {
47399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47400       };
47401     } catch (std::exception& e) {
47402       {
47403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47404       };
47405     } catch (Dali::DaliException e) {
47406       {
47407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47408       };
47409     } catch (...) {
47410       {
47411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47412       };
47413     }
47414   }
47415
47416   jresult = result;
47417   return jresult;
47418 }
47419
47420
47421 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
47422   int jresult ;
47423   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47424   int result;
47425
47426   arg1 = (Dali::Rect< int > *)jarg1;
47427   {
47428     try {
47429       result = (int)((Dali::Rect< int > const *)arg1)->Area();
47430     } catch (std::out_of_range& e) {
47431       {
47432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47433       };
47434     } catch (std::exception& e) {
47435       {
47436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47437       };
47438     } catch (Dali::DaliException e) {
47439       {
47440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47441       };
47442     } catch (...) {
47443       {
47444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47445       };
47446     }
47447   }
47448
47449   jresult = result;
47450   return jresult;
47451 }
47452
47453
47454 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
47455   unsigned int jresult ;
47456   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47457   Dali::Rect< int > *arg2 = 0 ;
47458   bool result;
47459
47460   arg1 = (Dali::Rect< int > *)jarg1;
47461   arg2 = (Dali::Rect< int > *)jarg2;
47462   if (!arg2) {
47463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47464     return 0;
47465   }
47466   {
47467     try {
47468       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
47469     } catch (std::out_of_range& e) {
47470       {
47471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47472       };
47473     } catch (std::exception& e) {
47474       {
47475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47476       };
47477     } catch (Dali::DaliException e) {
47478       {
47479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47480       };
47481     } catch (...) {
47482       {
47483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47484       };
47485     }
47486   }
47487
47488   jresult = result;
47489   return jresult;
47490 }
47491
47492
47493 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
47494   unsigned int jresult ;
47495   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47496   Dali::Rect< int > *arg2 = 0 ;
47497   bool result;
47498
47499   arg1 = (Dali::Rect< int > *)jarg1;
47500   arg2 = (Dali::Rect< int > *)jarg2;
47501   if (!arg2) {
47502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47503     return 0;
47504   }
47505   {
47506     try {
47507       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47508     } catch (std::out_of_range& e) {
47509       {
47510         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47511       };
47512     } catch (std::exception& e) {
47513       {
47514         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47515       };
47516     } catch (Dali::DaliException e) {
47517       {
47518         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47519       };
47520     } catch (...) {
47521       {
47522         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47523       };
47524     }
47525   }
47526
47527   jresult = result;
47528   return jresult;
47529 }
47530
47531
47532 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47533   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47534   int arg2 ;
47535
47536   arg1 = (Dali::Rect< int > *)jarg1;
47537   arg2 = (int)jarg2;
47538   if (arg1) (arg1)->x = arg2;
47539 }
47540
47541
47542 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47543   int jresult ;
47544   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47545   int result;
47546
47547   arg1 = (Dali::Rect< int > *)jarg1;
47548   result = (int) ((arg1)->x);
47549   jresult = result;
47550   return jresult;
47551 }
47552
47553
47554 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47555   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47556   int arg2 ;
47557
47558   arg1 = (Dali::Rect< int > *)jarg1;
47559   arg2 = (int)jarg2;
47560   if (arg1) (arg1)->left = arg2;
47561 }
47562
47563
47564 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47565   int jresult ;
47566   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47567   int result;
47568
47569   arg1 = (Dali::Rect< int > *)jarg1;
47570   result = (int) ((arg1)->left);
47571   jresult = result;
47572   return jresult;
47573 }
47574
47575
47576 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47577   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47578   int arg2 ;
47579
47580   arg1 = (Dali::Rect< int > *)jarg1;
47581   arg2 = (int)jarg2;
47582   if (arg1) (arg1)->y = arg2;
47583 }
47584
47585
47586 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47587   int jresult ;
47588   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47589   int result;
47590
47591   arg1 = (Dali::Rect< int > *)jarg1;
47592   result = (int) ((arg1)->y);
47593   jresult = result;
47594   return jresult;
47595 }
47596
47597
47598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47599   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47600   int arg2 ;
47601
47602   arg1 = (Dali::Rect< int > *)jarg1;
47603   arg2 = (int)jarg2;
47604   if (arg1) (arg1)->right = arg2;
47605 }
47606
47607
47608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47609   int jresult ;
47610   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47611   int result;
47612
47613   arg1 = (Dali::Rect< int > *)jarg1;
47614   result = (int) ((arg1)->right);
47615   jresult = result;
47616   return jresult;
47617 }
47618
47619
47620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47621   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47622   int arg2 ;
47623
47624   arg1 = (Dali::Rect< int > *)jarg1;
47625   arg2 = (int)jarg2;
47626   if (arg1) (arg1)->width = arg2;
47627 }
47628
47629
47630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47631   int jresult ;
47632   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47633   int result;
47634
47635   arg1 = (Dali::Rect< int > *)jarg1;
47636   result = (int) ((arg1)->width);
47637   jresult = result;
47638   return jresult;
47639 }
47640
47641
47642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47643   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47644   int arg2 ;
47645
47646   arg1 = (Dali::Rect< int > *)jarg1;
47647   arg2 = (int)jarg2;
47648   if (arg1) (arg1)->bottom = arg2;
47649 }
47650
47651
47652 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47653   int jresult ;
47654   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47655   int result;
47656
47657   arg1 = (Dali::Rect< int > *)jarg1;
47658   result = (int) ((arg1)->bottom);
47659   jresult = result;
47660   return jresult;
47661 }
47662
47663
47664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47665   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47666   int arg2 ;
47667
47668   arg1 = (Dali::Rect< int > *)jarg1;
47669   arg2 = (int)jarg2;
47670   if (arg1) (arg1)->height = arg2;
47671 }
47672
47673
47674 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47675   int jresult ;
47676   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47677   int result;
47678
47679   arg1 = (Dali::Rect< int > *)jarg1;
47680   result = (int) ((arg1)->height);
47681   jresult = result;
47682   return jresult;
47683 }
47684
47685
47686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47687   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47688   int arg2 ;
47689
47690   arg1 = (Dali::Rect< int > *)jarg1;
47691   arg2 = (int)jarg2;
47692   if (arg1) (arg1)->top = arg2;
47693 }
47694
47695
47696 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47697   int jresult ;
47698   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47699   int result;
47700
47701   arg1 = (Dali::Rect< int > *)jarg1;
47702   result = (int) ((arg1)->top);
47703   jresult = result;
47704   return jresult;
47705 }
47706
47707
47708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47709   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47710
47711   arg1 = (Dali::Rect< int > *)jarg1;
47712   {
47713     try {
47714       delete arg1;
47715     } catch (std::out_of_range& e) {
47716       {
47717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47718       };
47719     } catch (std::exception& e) {
47720       {
47721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47722       };
47723     } catch (Dali::DaliException e) {
47724       {
47725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47726       };
47727     } catch (...) {
47728       {
47729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47730       };
47731     }
47732   }
47733
47734 }
47735
47736
47737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47738   void * jresult ;
47739   Dali::Rect< float > *result = 0 ;
47740
47741   {
47742     try {
47743       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47744     } catch (std::out_of_range& e) {
47745       {
47746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (std::exception& e) {
47749       {
47750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47751       };
47752     } catch (Dali::DaliException e) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47755       };
47756     } catch (...) {
47757       {
47758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47759       };
47760     }
47761   }
47762
47763   jresult = (void *)result;
47764   return jresult;
47765 }
47766
47767
47768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47769   void * jresult ;
47770   float arg1 ;
47771   float arg2 ;
47772   float arg3 ;
47773   float arg4 ;
47774   Dali::Rect< float > *result = 0 ;
47775
47776   arg1 = (float)jarg1;
47777   arg2 = (float)jarg2;
47778   arg3 = (float)jarg4;
47779   arg4 = (float)jarg3;
47780   {
47781     try {
47782       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47783     } catch (std::out_of_range& e) {
47784       {
47785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47786       };
47787     } catch (std::exception& e) {
47788       {
47789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47790       };
47791     } catch (Dali::DaliException e) {
47792       {
47793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47794       };
47795     } catch (...) {
47796       {
47797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47798       };
47799     }
47800   }
47801
47802   jresult = (void *)result;
47803   return jresult;
47804 }
47805
47806
47807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47808   void * jresult ;
47809   Dali::Rect< float > *arg1 = 0 ;
47810   Dali::Rect< float > *result = 0 ;
47811
47812   arg1 = (Dali::Rect< float > *)jarg1;
47813   if (!arg1) {
47814     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47815     return 0;
47816   }
47817   {
47818     try {
47819       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47820     } catch (std::out_of_range& e) {
47821       {
47822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47823       };
47824     } catch (std::exception& e) {
47825       {
47826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47827       };
47828     } catch (Dali::DaliException e) {
47829       {
47830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47831       };
47832     } catch (...) {
47833       {
47834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47835       };
47836     }
47837   }
47838
47839   jresult = (void *)result;
47840   return jresult;
47841 }
47842
47843
47844 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47845   void * jresult ;
47846   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47847   Dali::Rect< float > *arg2 = 0 ;
47848   Dali::Rect< float > *result = 0 ;
47849
47850   arg1 = (Dali::Rect< float > *)jarg1;
47851   arg2 = (Dali::Rect< float > *)jarg2;
47852   if (!arg2) {
47853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47854     return 0;
47855   }
47856   {
47857     try {
47858       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47859     } catch (std::out_of_range& e) {
47860       {
47861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47862       };
47863     } catch (std::exception& e) {
47864       {
47865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47866       };
47867     } catch (Dali::DaliException e) {
47868       {
47869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47870       };
47871     } catch (...) {
47872       {
47873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47874       };
47875     }
47876   }
47877
47878   jresult = (void *)result;
47879   return jresult;
47880 }
47881
47882
47883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47884   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47885   float arg2 ;
47886   float arg3 ;
47887   float arg4 ;
47888   float arg5 ;
47889
47890   arg1 = (Dali::Rect< float > *)jarg1;
47891   arg2 = (float)jarg2;
47892   arg3 = (float)jarg3;
47893   arg4 = (float)jarg5;
47894   arg5 = (float)jarg4;
47895   {
47896     try {
47897       (arg1)->Set(arg2,arg3,arg4,arg5);
47898     } catch (std::out_of_range& e) {
47899       {
47900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47901       };
47902     } catch (std::exception& e) {
47903       {
47904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47905       };
47906     } catch (Dali::DaliException e) {
47907       {
47908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47909       };
47910     } catch (...) {
47911       {
47912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47913       };
47914     }
47915   }
47916
47917 }
47918
47919
47920 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47921   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47922   float arg2 ;
47923
47924   arg1 = (Dali::Rect< float > *)jarg1;
47925   arg2 = (float)jarg2;
47926   if (arg1) (arg1)->left = arg2;
47927 }
47928
47929
47930 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47931   float jresult ;
47932   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47933   float result;
47934
47935   arg1 = (Dali::Rect< float > *)jarg1;
47936   result = (float) ((arg1)->left);
47937   jresult = result;
47938   return jresult;
47939 }
47940
47941
47942 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47943   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47944   float arg2 ;
47945
47946   arg1 = (Dali::Rect< float > *)jarg1;
47947   arg2 = (float)jarg2;
47948   if (arg1) (arg1)->left = arg2;
47949 }
47950
47951
47952 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47953   float jresult ;
47954   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47955   float result;
47956
47957   arg1 = (Dali::Rect< float > *)jarg1;
47958   result = (float) ((arg1)->left);
47959   jresult = result;
47960   return jresult;
47961 }
47962
47963
47964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47965   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47966   float arg2 ;
47967
47968   arg1 = (Dali::Rect< float > *)jarg1;
47969   arg2 = (float)jarg2;
47970   if (arg1) (arg1)->right = arg2;
47971 }
47972
47973
47974 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47975   float jresult ;
47976   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47977   float result;
47978
47979   arg1 = (Dali::Rect< float > *)jarg1;
47980   result = (float) ((arg1)->right);
47981   jresult = result;
47982   return jresult;
47983 }
47984
47985
47986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47987   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47988   float arg2 ;
47989
47990   arg1 = (Dali::Rect< float > *)jarg1;
47991   arg2 = (float)jarg2;
47992   if (arg1) (arg1)->right = arg2;
47993 }
47994
47995
47996 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47997   float jresult ;
47998   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47999   float result;
48000
48001   arg1 = (Dali::Rect< float > *)jarg1;
48002   result = (float) ((arg1)->right);
48003   jresult = result;
48004   return jresult;
48005 }
48006
48007
48008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
48009   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48010   float arg2 ;
48011
48012   arg1 = (Dali::Rect< float > *)jarg1;
48013   arg2 = (float)jarg2;
48014   if (arg1) (arg1)->bottom = arg2;
48015 }
48016
48017
48018 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
48019   float jresult ;
48020   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48021   float result;
48022
48023   arg1 = (Dali::Rect< float > *)jarg1;
48024   result = (float) ((arg1)->bottom);
48025   jresult = result;
48026   return jresult;
48027 }
48028
48029
48030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
48031   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48032   float arg2 ;
48033
48034   arg1 = (Dali::Rect< float > *)jarg1;
48035   arg2 = (float)jarg2;
48036   if (arg1) (arg1)->top = arg2;
48037 }
48038
48039
48040 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
48041   float jresult ;
48042   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48043   float result;
48044
48045   arg1 = (Dali::Rect< float > *)jarg1;
48046   result = (float) ((arg1)->top);
48047   jresult = result;
48048   return jresult;
48049 }
48050
48051
48052 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
48053   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
48054
48055   arg1 = (Dali::Rect< float > *)jarg1;
48056   {
48057     try {
48058       delete arg1;
48059     } catch (std::out_of_range& e) {
48060       {
48061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48062       };
48063     } catch (std::exception& e) {
48064       {
48065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48066       };
48067     } catch (Dali::DaliException e) {
48068       {
48069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48070       };
48071     } catch (...) {
48072       {
48073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48074       };
48075     }
48076   }
48077
48078 }
48079
48080
48081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
48082   int jresult ;
48083   int result;
48084
48085   result = (int)Dali::Vector< int >::BaseType;
48086   jresult = (int)result;
48087   return jresult;
48088 }
48089
48090
48091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
48092   void * jresult ;
48093   Dali::Vector< int > *result = 0 ;
48094
48095   {
48096     try {
48097       result = (Dali::Vector< int > *)new Dali::Vector< int >();
48098     } catch (std::out_of_range& e) {
48099       {
48100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48101       };
48102     } catch (std::exception& e) {
48103       {
48104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48105       };
48106     } catch (Dali::DaliException e) {
48107       {
48108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48109       };
48110     } catch (...) {
48111       {
48112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48113       };
48114     }
48115   }
48116
48117   jresult = (void *)result;
48118   return jresult;
48119 }
48120
48121
48122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
48123   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48124
48125   arg1 = (Dali::Vector< int > *)jarg1;
48126   {
48127     try {
48128       delete arg1;
48129     } catch (std::out_of_range& e) {
48130       {
48131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48132       };
48133     } catch (std::exception& e) {
48134       {
48135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48136       };
48137     } catch (Dali::DaliException e) {
48138       {
48139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48140       };
48141     } catch (...) {
48142       {
48143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48144       };
48145     }
48146   }
48147
48148 }
48149
48150
48151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
48152   void * jresult ;
48153   Dali::Vector< int > *arg1 = 0 ;
48154   Dali::Vector< int > *result = 0 ;
48155
48156   arg1 = (Dali::Vector< int > *)jarg1;
48157   if (!arg1) {
48158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48159     return 0;
48160   }
48161   {
48162     try {
48163       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
48164     } catch (std::out_of_range& e) {
48165       {
48166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48167       };
48168     } catch (std::exception& e) {
48169       {
48170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48171       };
48172     } catch (Dali::DaliException e) {
48173       {
48174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48175       };
48176     } catch (...) {
48177       {
48178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48179       };
48180     }
48181   }
48182
48183   jresult = (void *)result;
48184   return jresult;
48185 }
48186
48187
48188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
48189   void * jresult ;
48190   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48191   Dali::Vector< int > *arg2 = 0 ;
48192   Dali::Vector< int > *result = 0 ;
48193
48194   arg1 = (Dali::Vector< int > *)jarg1;
48195   arg2 = (Dali::Vector< int > *)jarg2;
48196   if (!arg2) {
48197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
48198     return 0;
48199   }
48200   {
48201     try {
48202       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
48203     } catch (std::out_of_range& e) {
48204       {
48205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48206       };
48207     } catch (std::exception& e) {
48208       {
48209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48210       };
48211     } catch (Dali::DaliException e) {
48212       {
48213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48214       };
48215     } catch (...) {
48216       {
48217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48218       };
48219     }
48220   }
48221
48222   jresult = (void *)result;
48223   return jresult;
48224 }
48225
48226
48227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
48228   void * jresult ;
48229   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48230   Dali::Vector< int >::Iterator result;
48231
48232   arg1 = (Dali::Vector< int > *)jarg1;
48233   {
48234     try {
48235       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
48236     } catch (std::out_of_range& e) {
48237       {
48238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48239       };
48240     } catch (std::exception& e) {
48241       {
48242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48243       };
48244     } catch (Dali::DaliException e) {
48245       {
48246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48247       };
48248     } catch (...) {
48249       {
48250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48251       };
48252     }
48253   }
48254
48255   jresult = (void *)result;
48256   return jresult;
48257 }
48258
48259
48260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
48261   void * jresult ;
48262   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48263   Dali::Vector< int >::Iterator result;
48264
48265   arg1 = (Dali::Vector< int > *)jarg1;
48266   {
48267     try {
48268       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
48269     } catch (std::out_of_range& e) {
48270       {
48271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48272       };
48273     } catch (std::exception& e) {
48274       {
48275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48276       };
48277     } catch (Dali::DaliException e) {
48278       {
48279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48280       };
48281     } catch (...) {
48282       {
48283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48284       };
48285     }
48286   }
48287
48288   jresult = (void *)result;
48289   return jresult;
48290 }
48291
48292
48293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48294   void * jresult ;
48295   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48296   Dali::Vector< int >::SizeType arg2 ;
48297   Dali::Vector< int >::ItemType *result = 0 ;
48298
48299   arg1 = (Dali::Vector< int > *)jarg1;
48300   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48301   {
48302     try {
48303       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
48304     } catch (std::out_of_range& e) {
48305       {
48306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48307       };
48308     } catch (std::exception& e) {
48309       {
48310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48311       };
48312     } catch (Dali::DaliException e) {
48313       {
48314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48315       };
48316     } catch (...) {
48317       {
48318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48319       };
48320     }
48321   }
48322
48323   jresult = (void *)result;
48324   return jresult;
48325 }
48326
48327
48328 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
48329   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48330   Dali::Vector< int >::ItemType *arg2 = 0 ;
48331   Dali::Vector< int >::ItemType temp2 ;
48332
48333   arg1 = (Dali::Vector< int > *)jarg1;
48334   temp2 = (Dali::Vector< int >::ItemType)jarg2;
48335   arg2 = &temp2;
48336   {
48337     try {
48338       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
48339     } catch (std::out_of_range& e) {
48340       {
48341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48342       };
48343     } catch (std::exception& e) {
48344       {
48345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48346       };
48347     } catch (Dali::DaliException e) {
48348       {
48349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48350       };
48351     } catch (...) {
48352       {
48353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48354       };
48355     }
48356   }
48357
48358 }
48359
48360
48361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
48362   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48363   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48364   Dali::Vector< int >::ItemType *arg3 = 0 ;
48365   Dali::Vector< int >::ItemType temp3 ;
48366
48367   arg1 = (Dali::Vector< int > *)jarg1;
48368   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48369   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48370   arg3 = &temp3;
48371   {
48372     try {
48373       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48374     } catch (std::out_of_range& e) {
48375       {
48376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48377       };
48378     } catch (std::exception& e) {
48379       {
48380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48381       };
48382     } catch (Dali::DaliException e) {
48383       {
48384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48385       };
48386     } catch (...) {
48387       {
48388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48389       };
48390     }
48391   }
48392
48393 }
48394
48395
48396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48397   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48398   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48399   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48400   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
48401
48402   arg1 = (Dali::Vector< int > *)jarg1;
48403   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48404   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48405   arg4 = (Dali::Vector< int >::Iterator)jarg4;
48406   {
48407     try {
48408       (arg1)->Insert(arg2,arg3,arg4);
48409     } catch (std::out_of_range& e) {
48410       {
48411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48412       };
48413     } catch (std::exception& e) {
48414       {
48415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48416       };
48417     } catch (Dali::DaliException e) {
48418       {
48419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48420       };
48421     } catch (...) {
48422       {
48423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48424       };
48425     }
48426   }
48427
48428 }
48429
48430
48431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
48432   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48433   Dali::Vector< int >::SizeType arg2 ;
48434
48435   arg1 = (Dali::Vector< int > *)jarg1;
48436   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48437   {
48438     try {
48439       (arg1)->Reserve(arg2);
48440     } catch (std::out_of_range& e) {
48441       {
48442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48443       };
48444     } catch (std::exception& e) {
48445       {
48446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48447       };
48448     } catch (Dali::DaliException e) {
48449       {
48450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48451       };
48452     } catch (...) {
48453       {
48454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48455       };
48456     }
48457   }
48458
48459 }
48460
48461
48462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48463   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48464   Dali::Vector< int >::SizeType arg2 ;
48465
48466   arg1 = (Dali::Vector< int > *)jarg1;
48467   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48468   {
48469     try {
48470       (arg1)->Resize(arg2);
48471     } catch (std::out_of_range& e) {
48472       {
48473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48474       };
48475     } catch (std::exception& e) {
48476       {
48477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48478       };
48479     } catch (Dali::DaliException e) {
48480       {
48481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48482       };
48483     } catch (...) {
48484       {
48485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48486       };
48487     }
48488   }
48489
48490 }
48491
48492
48493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
48494   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48495   Dali::Vector< int >::SizeType arg2 ;
48496   Dali::Vector< int >::ItemType *arg3 = 0 ;
48497   Dali::Vector< int >::ItemType temp3 ;
48498
48499   arg1 = (Dali::Vector< int > *)jarg1;
48500   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48501   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48502   arg3 = &temp3;
48503   {
48504     try {
48505       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48506     } catch (std::out_of_range& e) {
48507       {
48508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48509       };
48510     } catch (std::exception& e) {
48511       {
48512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48513       };
48514     } catch (Dali::DaliException e) {
48515       {
48516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48517       };
48518     } catch (...) {
48519       {
48520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48521       };
48522     }
48523   }
48524
48525 }
48526
48527
48528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48529   void * jresult ;
48530   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48531   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48532   Dali::Vector< int >::Iterator result;
48533
48534   arg1 = (Dali::Vector< int > *)jarg1;
48535   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48536   {
48537     try {
48538       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48539     } catch (std::out_of_range& e) {
48540       {
48541         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48542       };
48543     } catch (std::exception& e) {
48544       {
48545         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48546       };
48547     } catch (Dali::DaliException e) {
48548       {
48549         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48550       };
48551     } catch (...) {
48552       {
48553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48554       };
48555     }
48556   }
48557
48558   jresult = (void *)result;
48559   return jresult;
48560 }
48561
48562
48563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48564   void * jresult ;
48565   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48566   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48567   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48568   Dali::Vector< int >::Iterator result;
48569
48570   arg1 = (Dali::Vector< int > *)jarg1;
48571   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48572   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48573   {
48574     try {
48575       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48576     } catch (std::out_of_range& e) {
48577       {
48578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48579       };
48580     } catch (std::exception& e) {
48581       {
48582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48583       };
48584     } catch (Dali::DaliException e) {
48585       {
48586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48587       };
48588     } catch (...) {
48589       {
48590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48591       };
48592     }
48593   }
48594
48595   jresult = (void *)result;
48596   return jresult;
48597 }
48598
48599
48600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48601   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48602   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48603
48604   arg1 = (Dali::Vector< int > *)jarg1;
48605   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48606   {
48607     try {
48608       (arg1)->Remove(arg2);
48609     } catch (std::out_of_range& e) {
48610       {
48611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48612       };
48613     } catch (std::exception& e) {
48614       {
48615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48616       };
48617     } catch (Dali::DaliException e) {
48618       {
48619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48620       };
48621     } catch (...) {
48622       {
48623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48624       };
48625     }
48626   }
48627
48628 }
48629
48630
48631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48632   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48633   Dali::Vector< int > *arg2 = 0 ;
48634
48635   arg1 = (Dali::Vector< int > *)jarg1;
48636   arg2 = (Dali::Vector< int > *)jarg2;
48637   if (!arg2) {
48638     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48639     return ;
48640   }
48641   {
48642     try {
48643       (arg1)->Swap(*arg2);
48644     } catch (std::out_of_range& e) {
48645       {
48646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48647       };
48648     } catch (std::exception& e) {
48649       {
48650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48651       };
48652     } catch (Dali::DaliException e) {
48653       {
48654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48655       };
48656     } catch (...) {
48657       {
48658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48659       };
48660     }
48661   }
48662
48663 }
48664
48665
48666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48667   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48668
48669   arg1 = (Dali::Vector< int > *)jarg1;
48670   {
48671     try {
48672       (arg1)->Clear();
48673     } catch (std::out_of_range& e) {
48674       {
48675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48676       };
48677     } catch (std::exception& e) {
48678       {
48679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48680       };
48681     } catch (Dali::DaliException e) {
48682       {
48683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48684       };
48685     } catch (...) {
48686       {
48687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48688       };
48689     }
48690   }
48691
48692 }
48693
48694
48695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48696   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48697
48698   arg1 = (Dali::Vector< int > *)jarg1;
48699   {
48700     try {
48701       (arg1)->Release();
48702     } catch (std::out_of_range& e) {
48703       {
48704         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48705       };
48706     } catch (std::exception& e) {
48707       {
48708         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48709       };
48710     } catch (Dali::DaliException e) {
48711       {
48712         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48713       };
48714     } catch (...) {
48715       {
48716         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48717       };
48718     }
48719   }
48720
48721 }
48722
48723
48724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48725   int jresult ;
48726   int result;
48727
48728   result = (int)Dali::Vector< float >::BaseType;
48729   jresult = (int)result;
48730   return jresult;
48731 }
48732
48733
48734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48735   void * jresult ;
48736   Dali::Vector< float > *result = 0 ;
48737
48738   {
48739     try {
48740       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48741     } catch (std::out_of_range& e) {
48742       {
48743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48744       };
48745     } catch (std::exception& e) {
48746       {
48747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48748       };
48749     } catch (Dali::DaliException e) {
48750       {
48751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48752       };
48753     } catch (...) {
48754       {
48755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48756       };
48757     }
48758   }
48759
48760   jresult = (void *)result;
48761   return jresult;
48762 }
48763
48764
48765 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48766   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48767
48768   arg1 = (Dali::Vector< float > *)jarg1;
48769   {
48770     try {
48771       delete arg1;
48772     } catch (std::out_of_range& e) {
48773       {
48774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48775       };
48776     } catch (std::exception& e) {
48777       {
48778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48779       };
48780     } catch (Dali::DaliException e) {
48781       {
48782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48783       };
48784     } catch (...) {
48785       {
48786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48787       };
48788     }
48789   }
48790
48791 }
48792
48793
48794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48795   void * jresult ;
48796   Dali::Vector< float > *arg1 = 0 ;
48797   Dali::Vector< float > *result = 0 ;
48798
48799   arg1 = (Dali::Vector< float > *)jarg1;
48800   if (!arg1) {
48801     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48802     return 0;
48803   }
48804   {
48805     try {
48806       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48807     } catch (std::out_of_range& e) {
48808       {
48809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48810       };
48811     } catch (std::exception& e) {
48812       {
48813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48814       };
48815     } catch (Dali::DaliException e) {
48816       {
48817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48818       };
48819     } catch (...) {
48820       {
48821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48822       };
48823     }
48824   }
48825
48826   jresult = (void *)result;
48827   return jresult;
48828 }
48829
48830
48831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48832   void * jresult ;
48833   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48834   Dali::Vector< float > *arg2 = 0 ;
48835   Dali::Vector< float > *result = 0 ;
48836
48837   arg1 = (Dali::Vector< float > *)jarg1;
48838   arg2 = (Dali::Vector< float > *)jarg2;
48839   if (!arg2) {
48840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48841     return 0;
48842   }
48843   {
48844     try {
48845       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48846     } catch (std::out_of_range& e) {
48847       {
48848         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48849       };
48850     } catch (std::exception& e) {
48851       {
48852         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48853       };
48854     } catch (Dali::DaliException e) {
48855       {
48856         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48857       };
48858     } catch (...) {
48859       {
48860         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48861       };
48862     }
48863   }
48864
48865   jresult = (void *)result;
48866   return jresult;
48867 }
48868
48869
48870 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48871   void * jresult ;
48872   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48873   Dali::Vector< float >::Iterator result;
48874
48875   arg1 = (Dali::Vector< float > *)jarg1;
48876   {
48877     try {
48878       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48879     } catch (std::out_of_range& e) {
48880       {
48881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48882       };
48883     } catch (std::exception& e) {
48884       {
48885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48886       };
48887     } catch (Dali::DaliException e) {
48888       {
48889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48890       };
48891     } catch (...) {
48892       {
48893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48894       };
48895     }
48896   }
48897
48898   jresult = (void *)result;
48899   return jresult;
48900 }
48901
48902
48903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48904   void * jresult ;
48905   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48906   Dali::Vector< float >::Iterator result;
48907
48908   arg1 = (Dali::Vector< float > *)jarg1;
48909   {
48910     try {
48911       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48912     } catch (std::out_of_range& e) {
48913       {
48914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48915       };
48916     } catch (std::exception& e) {
48917       {
48918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48919       };
48920     } catch (Dali::DaliException e) {
48921       {
48922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48923       };
48924     } catch (...) {
48925       {
48926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48927       };
48928     }
48929   }
48930
48931   jresult = (void *)result;
48932   return jresult;
48933 }
48934
48935
48936 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48937   void * jresult ;
48938   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48939   Dali::Vector< float >::SizeType arg2 ;
48940   Dali::Vector< float >::ItemType *result = 0 ;
48941
48942   arg1 = (Dali::Vector< float > *)jarg1;
48943   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48944   {
48945     try {
48946       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48947     } catch (std::out_of_range& e) {
48948       {
48949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48950       };
48951     } catch (std::exception& e) {
48952       {
48953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48954       };
48955     } catch (Dali::DaliException e) {
48956       {
48957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48958       };
48959     } catch (...) {
48960       {
48961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48962       };
48963     }
48964   }
48965
48966   jresult = (void *)result;
48967   return jresult;
48968 }
48969
48970
48971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48972   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48973   Dali::Vector< float >::ItemType *arg2 = 0 ;
48974   Dali::Vector< float >::ItemType temp2 ;
48975
48976   arg1 = (Dali::Vector< float > *)jarg1;
48977   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48978   arg2 = &temp2;
48979   {
48980     try {
48981       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48982     } catch (std::out_of_range& e) {
48983       {
48984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48985       };
48986     } catch (std::exception& e) {
48987       {
48988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48989       };
48990     } catch (Dali::DaliException e) {
48991       {
48992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48993       };
48994     } catch (...) {
48995       {
48996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48997       };
48998     }
48999   }
49000
49001 }
49002
49003
49004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
49005   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49006   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49007   Dali::Vector< float >::ItemType *arg3 = 0 ;
49008   Dali::Vector< float >::ItemType temp3 ;
49009
49010   arg1 = (Dali::Vector< float > *)jarg1;
49011   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49012   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49013   arg3 = &temp3;
49014   {
49015     try {
49016       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49017     } catch (std::out_of_range& e) {
49018       {
49019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49020       };
49021     } catch (std::exception& e) {
49022       {
49023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49024       };
49025     } catch (Dali::DaliException e) {
49026       {
49027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49028       };
49029     } catch (...) {
49030       {
49031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49032       };
49033     }
49034   }
49035
49036 }
49037
49038
49039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49040   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49041   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49042   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49043   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
49044
49045   arg1 = (Dali::Vector< float > *)jarg1;
49046   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49047   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49048   arg4 = (Dali::Vector< float >::Iterator)jarg4;
49049   {
49050     try {
49051       (arg1)->Insert(arg2,arg3,arg4);
49052     } catch (std::out_of_range& e) {
49053       {
49054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49055       };
49056     } catch (std::exception& e) {
49057       {
49058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49059       };
49060     } catch (Dali::DaliException e) {
49061       {
49062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49063       };
49064     } catch (...) {
49065       {
49066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49067       };
49068     }
49069   }
49070
49071 }
49072
49073
49074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
49075   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49076   Dali::Vector< float >::SizeType arg2 ;
49077
49078   arg1 = (Dali::Vector< float > *)jarg1;
49079   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49080   {
49081     try {
49082       (arg1)->Reserve(arg2);
49083     } catch (std::out_of_range& e) {
49084       {
49085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49086       };
49087     } catch (std::exception& e) {
49088       {
49089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49090       };
49091     } catch (Dali::DaliException e) {
49092       {
49093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49094       };
49095     } catch (...) {
49096       {
49097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49098       };
49099     }
49100   }
49101
49102 }
49103
49104 //// ========================= end of part 2 =============================
49105
49106 //// ========================== start part 3 ===============================
49107
49108
49109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49110   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49111   Dali::Vector< float >::SizeType arg2 ;
49112
49113   arg1 = (Dali::Vector< float > *)jarg1;
49114   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49115   {
49116     try {
49117       (arg1)->Resize(arg2);
49118     } catch (std::out_of_range& e) {
49119       {
49120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49121       };
49122     } catch (std::exception& e) {
49123       {
49124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49125       };
49126     } catch (Dali::DaliException e) {
49127       {
49128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49129       };
49130     } catch (...) {
49131       {
49132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49133       };
49134     }
49135   }
49136
49137 }
49138
49139
49140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
49141   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49142   Dali::Vector< float >::SizeType arg2 ;
49143   Dali::Vector< float >::ItemType *arg3 = 0 ;
49144   Dali::Vector< float >::ItemType temp3 ;
49145
49146   arg1 = (Dali::Vector< float > *)jarg1;
49147   arg2 = (Dali::Vector< float >::SizeType)jarg2;
49148   temp3 = (Dali::Vector< float >::ItemType)jarg3;
49149   arg3 = &temp3;
49150   {
49151     try {
49152       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
49153     } catch (std::out_of_range& e) {
49154       {
49155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49156       };
49157     } catch (std::exception& e) {
49158       {
49159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49160       };
49161     } catch (Dali::DaliException e) {
49162       {
49163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49164       };
49165     } catch (...) {
49166       {
49167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49168       };
49169     }
49170   }
49171
49172 }
49173
49174
49175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
49176   void * jresult ;
49177   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49178   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49179   Dali::Vector< float >::Iterator result;
49180
49181   arg1 = (Dali::Vector< float > *)jarg1;
49182   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49183   {
49184     try {
49185       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
49186     } catch (std::out_of_range& e) {
49187       {
49188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49189       };
49190     } catch (std::exception& e) {
49191       {
49192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49193       };
49194     } catch (Dali::DaliException e) {
49195       {
49196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49197       };
49198     } catch (...) {
49199       {
49200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49201       };
49202     }
49203   }
49204
49205   jresult = (void *)result;
49206   return jresult;
49207 }
49208
49209
49210 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
49211   void * jresult ;
49212   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49213   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49214   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
49215   Dali::Vector< float >::Iterator result;
49216
49217   arg1 = (Dali::Vector< float > *)jarg1;
49218   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49219   arg3 = (Dali::Vector< float >::Iterator)jarg3;
49220   {
49221     try {
49222       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
49223     } catch (std::out_of_range& e) {
49224       {
49225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49226       };
49227     } catch (std::exception& e) {
49228       {
49229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49230       };
49231     } catch (Dali::DaliException e) {
49232       {
49233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49234       };
49235     } catch (...) {
49236       {
49237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49238       };
49239     }
49240   }
49241
49242   jresult = (void *)result;
49243   return jresult;
49244 }
49245
49246
49247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
49248   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49249   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
49250
49251   arg1 = (Dali::Vector< float > *)jarg1;
49252   arg2 = (Dali::Vector< float >::Iterator)jarg2;
49253   {
49254     try {
49255       (arg1)->Remove(arg2);
49256     } catch (std::out_of_range& e) {
49257       {
49258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49259       };
49260     } catch (std::exception& e) {
49261       {
49262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49263       };
49264     } catch (Dali::DaliException e) {
49265       {
49266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49267       };
49268     } catch (...) {
49269       {
49270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49271       };
49272     }
49273   }
49274
49275 }
49276
49277
49278 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
49279   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49280   Dali::Vector< float > *arg2 = 0 ;
49281
49282   arg1 = (Dali::Vector< float > *)jarg1;
49283   arg2 = (Dali::Vector< float > *)jarg2;
49284   if (!arg2) {
49285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
49286     return ;
49287   }
49288   {
49289     try {
49290       (arg1)->Swap(*arg2);
49291     } catch (std::out_of_range& e) {
49292       {
49293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49294       };
49295     } catch (std::exception& e) {
49296       {
49297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49298       };
49299     } catch (Dali::DaliException e) {
49300       {
49301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49302       };
49303     } catch (...) {
49304       {
49305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49306       };
49307     }
49308   }
49309
49310 }
49311
49312
49313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
49314   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49315
49316   arg1 = (Dali::Vector< float > *)jarg1;
49317   {
49318     try {
49319       (arg1)->Clear();
49320     } catch (std::out_of_range& e) {
49321       {
49322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49323       };
49324     } catch (std::exception& e) {
49325       {
49326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49327       };
49328     } catch (Dali::DaliException e) {
49329       {
49330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49331       };
49332     } catch (...) {
49333       {
49334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49335       };
49336     }
49337   }
49338
49339 }
49340
49341
49342 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
49343   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
49344
49345   arg1 = (Dali::Vector< float > *)jarg1;
49346   {
49347     try {
49348       (arg1)->Release();
49349     } catch (std::out_of_range& e) {
49350       {
49351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49352       };
49353     } catch (std::exception& e) {
49354       {
49355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49356       };
49357     } catch (Dali::DaliException e) {
49358       {
49359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49360       };
49361     } catch (...) {
49362       {
49363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49364       };
49365     }
49366   }
49367
49368 }
49369
49370
49371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
49372   int jresult ;
49373   int result;
49374
49375   result = (int)Dali::Vector< unsigned char >::BaseType;
49376   jresult = (int)result;
49377   return jresult;
49378 }
49379
49380
49381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
49382   void * jresult ;
49383   Dali::Vector< unsigned char > *result = 0 ;
49384
49385   {
49386     try {
49387       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
49388     } catch (std::out_of_range& e) {
49389       {
49390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49391       };
49392     } catch (std::exception& e) {
49393       {
49394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49395       };
49396     } catch (Dali::DaliException e) {
49397       {
49398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49399       };
49400     } catch (...) {
49401       {
49402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49403       };
49404     }
49405   }
49406
49407   jresult = (void *)result;
49408   return jresult;
49409 }
49410
49411
49412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
49413   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49414
49415   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49416   {
49417     try {
49418       delete arg1;
49419     } catch (std::out_of_range& e) {
49420       {
49421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49422       };
49423     } catch (std::exception& e) {
49424       {
49425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49426       };
49427     } catch (Dali::DaliException e) {
49428       {
49429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49430       };
49431     } catch (...) {
49432       {
49433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49434       };
49435     }
49436   }
49437
49438 }
49439
49440
49441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
49442   void * jresult ;
49443   Dali::Vector< unsigned char > *arg1 = 0 ;
49444   Dali::Vector< unsigned char > *result = 0 ;
49445
49446   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49447   if (!arg1) {
49448     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49449     return 0;
49450   }
49451   {
49452     try {
49453       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
49454     } catch (std::out_of_range& e) {
49455       {
49456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49457       };
49458     } catch (std::exception& e) {
49459       {
49460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49461       };
49462     } catch (Dali::DaliException e) {
49463       {
49464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49465       };
49466     } catch (...) {
49467       {
49468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49469       };
49470     }
49471   }
49472
49473   jresult = (void *)result;
49474   return jresult;
49475 }
49476
49477
49478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
49479   void * jresult ;
49480   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49481   Dali::Vector< unsigned char > *arg2 = 0 ;
49482   Dali::Vector< unsigned char > *result = 0 ;
49483
49484   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49485   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49486   if (!arg2) {
49487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
49488     return 0;
49489   }
49490   {
49491     try {
49492       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
49493     } catch (std::out_of_range& e) {
49494       {
49495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49496       };
49497     } catch (std::exception& e) {
49498       {
49499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49500       };
49501     } catch (Dali::DaliException e) {
49502       {
49503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49504       };
49505     } catch (...) {
49506       {
49507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49508       };
49509     }
49510   }
49511
49512   jresult = (void *)result;
49513   return jresult;
49514 }
49515
49516
49517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49518   void * jresult ;
49519   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49520   Dali::Vector< unsigned char >::Iterator result;
49521
49522   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49523   {
49524     try {
49525       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49526     } catch (std::out_of_range& e) {
49527       {
49528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49529       };
49530     } catch (std::exception& e) {
49531       {
49532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49533       };
49534     } catch (Dali::DaliException e) {
49535       {
49536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49537       };
49538     } catch (...) {
49539       {
49540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49541       };
49542     }
49543   }
49544
49545   jresult = (void *)result;
49546   return jresult;
49547 }
49548
49549
49550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49551   void * jresult ;
49552   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49553   Dali::Vector< unsigned char >::Iterator result;
49554
49555   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49556   {
49557     try {
49558       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49559     } catch (std::out_of_range& e) {
49560       {
49561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49562       };
49563     } catch (std::exception& e) {
49564       {
49565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49566       };
49567     } catch (Dali::DaliException e) {
49568       {
49569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49570       };
49571     } catch (...) {
49572       {
49573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49574       };
49575     }
49576   }
49577
49578   jresult = (void *)result;
49579   return jresult;
49580 }
49581
49582
49583 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49584   void * jresult ;
49585   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49586   Dali::Vector< unsigned char >::SizeType arg2 ;
49587   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49588
49589   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49590   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49591   {
49592     try {
49593       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49594     } catch (std::out_of_range& e) {
49595       {
49596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49597       };
49598     } catch (std::exception& e) {
49599       {
49600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49601       };
49602     } catch (Dali::DaliException e) {
49603       {
49604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49605       };
49606     } catch (...) {
49607       {
49608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49609       };
49610     }
49611   }
49612
49613   jresult = (void *)result;
49614   return jresult;
49615 }
49616
49617
49618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49619   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49620   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49621   Dali::Vector< unsigned char >::ItemType temp2 ;
49622
49623   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49624   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49625   arg2 = &temp2;
49626   {
49627     try {
49628       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49629     } catch (std::out_of_range& e) {
49630       {
49631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49632       };
49633     } catch (std::exception& e) {
49634       {
49635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49636       };
49637     } catch (Dali::DaliException e) {
49638       {
49639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49640       };
49641     } catch (...) {
49642       {
49643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49644       };
49645     }
49646   }
49647
49648 }
49649
49650
49651 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49652   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49653   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49654   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49655   Dali::Vector< unsigned char >::ItemType temp3 ;
49656
49657   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49658   arg2 = jarg2;
49659   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49660   arg3 = &temp3;
49661   {
49662     try {
49663       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49664     } catch (std::out_of_range& e) {
49665       {
49666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49667       };
49668     } catch (std::exception& e) {
49669       {
49670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49671       };
49672     } catch (Dali::DaliException e) {
49673       {
49674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49675       };
49676     } catch (...) {
49677       {
49678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49679       };
49680     }
49681   }
49682
49683
49684
49685 }
49686
49687
49688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49689   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49690   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49691   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49692   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49693
49694   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49695   arg2 = jarg2;
49696   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49697   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49698   {
49699     try {
49700       (arg1)->Insert(arg2,arg3,arg4);
49701     } catch (std::out_of_range& e) {
49702       {
49703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49704       };
49705     } catch (std::exception& e) {
49706       {
49707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49708       };
49709     } catch (Dali::DaliException e) {
49710       {
49711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49712       };
49713     } catch (...) {
49714       {
49715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49716       };
49717     }
49718   }
49719
49720
49721
49722 }
49723
49724
49725 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49726   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49727   Dali::Vector< unsigned char >::SizeType arg2 ;
49728
49729   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49730   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49731   {
49732     try {
49733       (arg1)->Reserve(arg2);
49734     } catch (std::out_of_range& e) {
49735       {
49736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49737       };
49738     } catch (std::exception& e) {
49739       {
49740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49741       };
49742     } catch (Dali::DaliException e) {
49743       {
49744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49745       };
49746     } catch (...) {
49747       {
49748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49749       };
49750     }
49751   }
49752
49753 }
49754
49755
49756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49757   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49758   Dali::Vector< unsigned char >::SizeType arg2 ;
49759
49760   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49761   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49762   {
49763     try {
49764       (arg1)->Resize(arg2);
49765     } catch (std::out_of_range& e) {
49766       {
49767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49768       };
49769     } catch (std::exception& e) {
49770       {
49771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49772       };
49773     } catch (Dali::DaliException e) {
49774       {
49775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49776       };
49777     } catch (...) {
49778       {
49779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49780       };
49781     }
49782   }
49783
49784 }
49785
49786
49787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49788   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49789   Dali::Vector< unsigned char >::SizeType arg2 ;
49790   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49791   Dali::Vector< unsigned char >::ItemType temp3 ;
49792
49793   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49794   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49795   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49796   arg3 = &temp3;
49797   {
49798     try {
49799       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49800     } catch (std::out_of_range& e) {
49801       {
49802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49803       };
49804     } catch (std::exception& e) {
49805       {
49806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49807       };
49808     } catch (Dali::DaliException e) {
49809       {
49810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49811       };
49812     } catch (...) {
49813       {
49814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49815       };
49816     }
49817   }
49818
49819 }
49820
49821
49822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49823   void * jresult ;
49824   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49825   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49826   Dali::Vector< unsigned char >::Iterator result;
49827
49828   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49829   arg2 = jarg2;
49830   {
49831     try {
49832       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49833     } catch (std::out_of_range& e) {
49834       {
49835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49836       };
49837     } catch (std::exception& e) {
49838       {
49839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49840       };
49841     } catch (Dali::DaliException e) {
49842       {
49843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49844       };
49845     } catch (...) {
49846       {
49847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49848       };
49849     }
49850   }
49851
49852   jresult = (void *)result;
49853
49854
49855   return jresult;
49856 }
49857
49858
49859 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49860   void * jresult ;
49861   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49862   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49863   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49864   Dali::Vector< unsigned char >::Iterator result;
49865
49866   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49867   arg2 = jarg2;
49868   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49869   {
49870     try {
49871       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49872     } catch (std::out_of_range& e) {
49873       {
49874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49875       };
49876     } catch (std::exception& e) {
49877       {
49878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49879       };
49880     } catch (Dali::DaliException e) {
49881       {
49882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49883       };
49884     } catch (...) {
49885       {
49886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49887       };
49888     }
49889   }
49890
49891   jresult = (void *)result;
49892
49893
49894   return jresult;
49895 }
49896
49897
49898 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49899   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49900   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49901
49902   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49903   arg2 = jarg2;
49904   {
49905     try {
49906       (arg1)->Remove(arg2);
49907     } catch (std::out_of_range& e) {
49908       {
49909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49910       };
49911     } catch (std::exception& e) {
49912       {
49913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49914       };
49915     } catch (Dali::DaliException e) {
49916       {
49917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49918       };
49919     } catch (...) {
49920       {
49921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49922       };
49923     }
49924   }
49925
49926
49927
49928 }
49929
49930
49931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49932   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49933   Dali::Vector< unsigned char > *arg2 = 0 ;
49934
49935   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49936   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49937   if (!arg2) {
49938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49939     return ;
49940   }
49941   {
49942     try {
49943       (arg1)->Swap(*arg2);
49944     } catch (std::out_of_range& e) {
49945       {
49946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49947       };
49948     } catch (std::exception& e) {
49949       {
49950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49951       };
49952     } catch (Dali::DaliException e) {
49953       {
49954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49955       };
49956     } catch (...) {
49957       {
49958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49959       };
49960     }
49961   }
49962
49963 }
49964
49965
49966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49967   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49968
49969   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49970   {
49971     try {
49972       (arg1)->Clear();
49973     } catch (std::out_of_range& e) {
49974       {
49975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49976       };
49977     } catch (std::exception& e) {
49978       {
49979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49980       };
49981     } catch (Dali::DaliException e) {
49982       {
49983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49984       };
49985     } catch (...) {
49986       {
49987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49988       };
49989     }
49990   }
49991
49992 }
49993
49994
49995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49996   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49997
49998   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49999   {
50000     try {
50001       (arg1)->Release();
50002     } catch (std::out_of_range& e) {
50003       {
50004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50005       };
50006     } catch (std::exception& e) {
50007       {
50008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50009       };
50010     } catch (Dali::DaliException e) {
50011       {
50012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50013       };
50014     } catch (...) {
50015       {
50016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50017       };
50018     }
50019   }
50020
50021 }
50022
50023
50024 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
50025   int jresult ;
50026   int result;
50027
50028   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
50029   jresult = (int)result;
50030   return jresult;
50031 }
50032
50033
50034 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
50035   void * jresult ;
50036   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50037
50038   {
50039     try {
50040       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
50041     } catch (std::out_of_range& e) {
50042       {
50043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50044       };
50045     } catch (std::exception& e) {
50046       {
50047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50048       };
50049     } catch (Dali::DaliException e) {
50050       {
50051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50052       };
50053     } catch (...) {
50054       {
50055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50056       };
50057     }
50058   }
50059
50060   jresult = (void *)result;
50061   return jresult;
50062 }
50063
50064
50065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
50066   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50067
50068   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50069   {
50070     try {
50071       delete arg1;
50072     } catch (std::out_of_range& e) {
50073       {
50074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50075       };
50076     } catch (std::exception& e) {
50077       {
50078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50079       };
50080     } catch (Dali::DaliException e) {
50081       {
50082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50083       };
50084     } catch (...) {
50085       {
50086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50087       };
50088     }
50089   }
50090
50091 }
50092
50093
50094 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
50095   void * jresult ;
50096   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
50097   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50098
50099   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50100   if (!arg1) {
50101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50102     return 0;
50103   }
50104   {
50105     try {
50106       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
50107     } catch (std::out_of_range& e) {
50108       {
50109         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50110       };
50111     } catch (std::exception& e) {
50112       {
50113         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50114       };
50115     } catch (Dali::DaliException e) {
50116       {
50117         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50118       };
50119     } catch (...) {
50120       {
50121         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50122       };
50123     }
50124   }
50125
50126   jresult = (void *)result;
50127   return jresult;
50128 }
50129
50130
50131 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
50132   void * jresult ;
50133   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50134   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50135   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
50136
50137   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50138   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50139   if (!arg2) {
50140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
50141     return 0;
50142   }
50143   {
50144     try {
50145       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
50146     } catch (std::out_of_range& e) {
50147       {
50148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50149       };
50150     } catch (std::exception& e) {
50151       {
50152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50153       };
50154     } catch (Dali::DaliException e) {
50155       {
50156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50157       };
50158     } catch (...) {
50159       {
50160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50161       };
50162     }
50163   }
50164
50165   jresult = (void *)result;
50166   return jresult;
50167 }
50168
50169
50170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
50171   void * jresult ;
50172   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50173   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50174
50175   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50176   {
50177     try {
50178       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
50179     } catch (std::out_of_range& e) {
50180       {
50181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50182       };
50183     } catch (std::exception& e) {
50184       {
50185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50186       };
50187     } catch (Dali::DaliException e) {
50188       {
50189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50190       };
50191     } catch (...) {
50192       {
50193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50194       };
50195     }
50196   }
50197
50198   jresult = (void *)result;
50199   return jresult;
50200 }
50201
50202
50203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
50204   void * jresult ;
50205   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50206   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50207
50208   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50209   {
50210     try {
50211       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
50212     } catch (std::out_of_range& e) {
50213       {
50214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50215       };
50216     } catch (std::exception& e) {
50217       {
50218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50219       };
50220     } catch (Dali::DaliException e) {
50221       {
50222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50223       };
50224     } catch (...) {
50225       {
50226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50227       };
50228     }
50229   }
50230
50231   jresult = (void *)result;
50232   return jresult;
50233 }
50234
50235
50236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
50237   void * jresult ;
50238   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50239   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50240   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
50241
50242   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50243   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50244   {
50245     try {
50246       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
50247     } catch (std::out_of_range& e) {
50248       {
50249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50250       };
50251     } catch (std::exception& e) {
50252       {
50253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50254       };
50255     } catch (Dali::DaliException e) {
50256       {
50257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50258       };
50259     } catch (...) {
50260       {
50261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50262       };
50263     }
50264   }
50265
50266   jresult = (void *)result;
50267   return jresult;
50268 }
50269
50270
50271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
50272   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50273   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
50274
50275   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50276   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
50277   if (!arg2) {
50278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50279     return ;
50280   }
50281   {
50282     try {
50283       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
50284     } catch (std::out_of_range& e) {
50285       {
50286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50287       };
50288     } catch (std::exception& e) {
50289       {
50290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50291       };
50292     } catch (Dali::DaliException e) {
50293       {
50294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50295       };
50296     } catch (...) {
50297       {
50298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50299       };
50300     }
50301   }
50302
50303 }
50304
50305
50306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
50307   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50308   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50309   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50310
50311   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50312   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50313   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50314   if (!arg3) {
50315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50316     return ;
50317   }
50318   {
50319     try {
50320       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50321     } catch (std::out_of_range& e) {
50322       {
50323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50324       };
50325     } catch (std::exception& e) {
50326       {
50327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50328       };
50329     } catch (Dali::DaliException e) {
50330       {
50331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50332       };
50333     } catch (...) {
50334       {
50335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50336       };
50337     }
50338   }
50339
50340 }
50341
50342
50343 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
50344   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50345   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50346   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50347   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50348
50349   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50350   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50351   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50352   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
50353   {
50354     try {
50355       (arg1)->Insert(arg2,arg3,arg4);
50356     } catch (std::out_of_range& e) {
50357       {
50358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50359       };
50360     } catch (std::exception& e) {
50361       {
50362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50363       };
50364     } catch (Dali::DaliException e) {
50365       {
50366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50367       };
50368     } catch (...) {
50369       {
50370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50371       };
50372     }
50373   }
50374
50375 }
50376
50377
50378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
50379   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50380   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50381
50382   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50383   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50384   {
50385     try {
50386       (arg1)->Reserve(arg2);
50387     } catch (std::out_of_range& e) {
50388       {
50389         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50390       };
50391     } catch (std::exception& e) {
50392       {
50393         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50394       };
50395     } catch (Dali::DaliException e) {
50396       {
50397         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50398       };
50399     } catch (...) {
50400       {
50401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50402       };
50403     }
50404   }
50405
50406 }
50407
50408
50409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
50410   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50411   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50412
50413   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50414   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50415   {
50416     try {
50417       (arg1)->Resize(arg2);
50418     } catch (std::out_of_range& e) {
50419       {
50420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50421       };
50422     } catch (std::exception& e) {
50423       {
50424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50425       };
50426     } catch (Dali::DaliException e) {
50427       {
50428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50429       };
50430     } catch (...) {
50431       {
50432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50433       };
50434     }
50435   }
50436
50437 }
50438
50439
50440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
50441   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50442   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
50443   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
50444
50445   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50446   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
50447   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
50448   if (!arg3) {
50449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
50450     return ;
50451   }
50452   {
50453     try {
50454       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
50455     } catch (std::out_of_range& e) {
50456       {
50457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50458       };
50459     } catch (std::exception& e) {
50460       {
50461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50462       };
50463     } catch (Dali::DaliException e) {
50464       {
50465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50466       };
50467     } catch (...) {
50468       {
50469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50470       };
50471     }
50472   }
50473
50474 }
50475
50476
50477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
50478   void * jresult ;
50479   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50480   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50481   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50482
50483   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50484   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50485   {
50486     try {
50487       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
50488     } catch (std::out_of_range& e) {
50489       {
50490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50491       };
50492     } catch (std::exception& e) {
50493       {
50494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50495       };
50496     } catch (Dali::DaliException e) {
50497       {
50498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50499       };
50500     } catch (...) {
50501       {
50502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50503       };
50504     }
50505   }
50506
50507   jresult = (void *)result;
50508   return jresult;
50509 }
50510
50511
50512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50513   void * jresult ;
50514   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50515   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50516   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50517   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50518
50519   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50520   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50521   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50522   {
50523     try {
50524       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50525     } catch (std::out_of_range& e) {
50526       {
50527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50528       };
50529     } catch (std::exception& e) {
50530       {
50531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50532       };
50533     } catch (Dali::DaliException e) {
50534       {
50535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50536       };
50537     } catch (...) {
50538       {
50539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50540       };
50541     }
50542   }
50543
50544   jresult = (void *)result;
50545   return jresult;
50546 }
50547
50548
50549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50550   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50551   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50552
50553   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50554   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50555   {
50556     try {
50557       (arg1)->Remove(arg2);
50558     } catch (std::out_of_range& e) {
50559       {
50560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50561       };
50562     } catch (std::exception& e) {
50563       {
50564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50565       };
50566     } catch (Dali::DaliException e) {
50567       {
50568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50569       };
50570     } catch (...) {
50571       {
50572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50573       };
50574     }
50575   }
50576
50577 }
50578
50579
50580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50581   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50582   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50583
50584   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50585   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50586   if (!arg2) {
50587     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50588     return ;
50589   }
50590   {
50591     try {
50592       (arg1)->Swap(*arg2);
50593     } catch (std::out_of_range& e) {
50594       {
50595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50596       };
50597     } catch (std::exception& e) {
50598       {
50599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50600       };
50601     } catch (Dali::DaliException e) {
50602       {
50603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50604       };
50605     } catch (...) {
50606       {
50607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50608       };
50609     }
50610   }
50611
50612 }
50613
50614
50615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50616   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50617
50618   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50619   {
50620     try {
50621       (arg1)->Clear();
50622     } catch (std::out_of_range& e) {
50623       {
50624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50625       };
50626     } catch (std::exception& e) {
50627       {
50628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50629       };
50630     } catch (Dali::DaliException e) {
50631       {
50632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50633       };
50634     } catch (...) {
50635       {
50636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50637       };
50638     }
50639   }
50640
50641 }
50642
50643
50644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50645   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50646
50647   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50648   {
50649     try {
50650       (arg1)->Release();
50651     } catch (std::out_of_range& e) {
50652       {
50653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50654       };
50655     } catch (std::exception& e) {
50656       {
50657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50658       };
50659     } catch (Dali::DaliException e) {
50660       {
50661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50662       };
50663     } catch (...) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50666       };
50667     }
50668   }
50669
50670 }
50671
50672
50673 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50674   void * jresult ;
50675   Dali::Signal< void () > *result = 0 ;
50676
50677   {
50678     try {
50679       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50680     } catch (std::out_of_range& e) {
50681       {
50682         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50683       };
50684     } catch (std::exception& e) {
50685       {
50686         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50687       };
50688     } catch (Dali::DaliException e) {
50689       {
50690         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50691       };
50692     } catch (...) {
50693       {
50694         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50695       };
50696     }
50697   }
50698
50699   jresult = (void *)result;
50700   return jresult;
50701 }
50702
50703
50704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50705   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50706
50707   arg1 = (Dali::Signal< void () > *)jarg1;
50708   {
50709     try {
50710       delete arg1;
50711     } catch (std::out_of_range& e) {
50712       {
50713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50714       };
50715     } catch (std::exception& e) {
50716       {
50717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50718       };
50719     } catch (Dali::DaliException e) {
50720       {
50721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50722       };
50723     } catch (...) {
50724       {
50725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50726       };
50727     }
50728   }
50729
50730 }
50731
50732
50733 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50734   unsigned int jresult ;
50735   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50736   bool result;
50737
50738   arg1 = (Dali::Signal< void () > *)jarg1;
50739   {
50740     try {
50741       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50742     } catch (std::out_of_range& e) {
50743       {
50744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50745       };
50746     } catch (std::exception& e) {
50747       {
50748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50749       };
50750     } catch (Dali::DaliException e) {
50751       {
50752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50753       };
50754     } catch (...) {
50755       {
50756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50757       };
50758     }
50759   }
50760
50761   jresult = result;
50762   return jresult;
50763 }
50764
50765
50766 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50767   unsigned long jresult ;
50768   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50769   std::size_t result;
50770
50771   arg1 = (Dali::Signal< void () > *)jarg1;
50772   {
50773     try {
50774       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50775     } catch (std::out_of_range& e) {
50776       {
50777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50778       };
50779     } catch (std::exception& e) {
50780       {
50781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50782       };
50783     } catch (Dali::DaliException e) {
50784       {
50785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50786       };
50787     } catch (...) {
50788       {
50789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50790       };
50791     }
50792   }
50793
50794   jresult = (unsigned long)result;
50795   return jresult;
50796 }
50797
50798
50799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50800   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50801   void (*arg2)() = (void (*)()) 0 ;
50802
50803   arg1 = (Dali::Signal< void () > *)jarg1;
50804   arg2 = (void (*)())jarg2;
50805   {
50806     try {
50807       (arg1)->Connect(arg2);
50808     } catch (std::out_of_range& e) {
50809       {
50810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50811       };
50812     } catch (std::exception& e) {
50813       {
50814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50815       };
50816     } catch (Dali::DaliException e) {
50817       {
50818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50819       };
50820     } catch (...) {
50821       {
50822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50823       };
50824     }
50825   }
50826
50827 }
50828
50829
50830 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50831   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50832   void (*arg2)() = (void (*)()) 0 ;
50833
50834   arg1 = (Dali::Signal< void () > *)jarg1;
50835   arg2 = (void (*)())jarg2;
50836   {
50837     try {
50838       (arg1)->Disconnect(arg2);
50839     } catch (std::out_of_range& e) {
50840       {
50841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50842       };
50843     } catch (std::exception& e) {
50844       {
50845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50846       };
50847     } catch (Dali::DaliException e) {
50848       {
50849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50850       };
50851     } catch (...) {
50852       {
50853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50854       };
50855     }
50856   }
50857
50858 }
50859
50860
50861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50862   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50863   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50864   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50865
50866   arg1 = (Dali::Signal< void () > *)jarg1;
50867   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50868   arg3 = (Dali::FunctorDelegate *)jarg3;
50869   {
50870     try {
50871       (arg1)->Connect(arg2,arg3);
50872     } catch (std::out_of_range& e) {
50873       {
50874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50875       };
50876     } catch (std::exception& e) {
50877       {
50878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50879       };
50880     } catch (Dali::DaliException e) {
50881       {
50882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50883       };
50884     } catch (...) {
50885       {
50886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50887       };
50888     }
50889   }
50890
50891 }
50892
50893
50894 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50895   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50896
50897   arg1 = (Dali::Signal< void () > *)jarg1;
50898   {
50899     try {
50900       (arg1)->Emit();
50901     } catch (std::out_of_range& e) {
50902       {
50903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50904       };
50905     } catch (std::exception& e) {
50906       {
50907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50908       };
50909     } catch (Dali::DaliException e) {
50910       {
50911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50912       };
50913     } catch (...) {
50914       {
50915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50916       };
50917     }
50918   }
50919
50920 }
50921
50922
50923 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50924   unsigned int jresult ;
50925   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50926   bool result;
50927
50928   arg1 = (Dali::Signal< void (float) > *)jarg1;
50929   {
50930     try {
50931       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50932     } catch (std::out_of_range& e) {
50933       {
50934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50935       };
50936     } catch (std::exception& e) {
50937       {
50938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50939       };
50940     } catch (Dali::DaliException e) {
50941       {
50942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50943       };
50944     } catch (...) {
50945       {
50946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50947       };
50948     }
50949   }
50950
50951   jresult = result;
50952   return jresult;
50953 }
50954
50955
50956 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50957   unsigned long jresult ;
50958   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50959   std::size_t result;
50960
50961   arg1 = (Dali::Signal< void (float) > *)jarg1;
50962   {
50963     try {
50964       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50965     } catch (std::out_of_range& e) {
50966       {
50967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50968       };
50969     } catch (std::exception& e) {
50970       {
50971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50972       };
50973     } catch (Dali::DaliException e) {
50974       {
50975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50976       };
50977     } catch (...) {
50978       {
50979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50980       };
50981     }
50982   }
50983
50984   jresult = (unsigned long)result;
50985   return jresult;
50986 }
50987
50988
50989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50990   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50991   void (*arg2)(float) = (void (*)(float)) 0 ;
50992
50993   arg1 = (Dali::Signal< void (float) > *)jarg1;
50994   arg2 = (void (*)(float))jarg2;
50995   {
50996     try {
50997       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50998     } catch (std::out_of_range& e) {
50999       {
51000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51001       };
51002     } catch (std::exception& e) {
51003       {
51004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51005       };
51006     } catch (Dali::DaliException e) {
51007       {
51008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51009       };
51010     } catch (...) {
51011       {
51012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51013       };
51014     }
51015   }
51016
51017 }
51018
51019
51020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
51021   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51022   void (*arg2)(float) = (void (*)(float)) 0 ;
51023
51024   arg1 = (Dali::Signal< void (float) > *)jarg1;
51025   arg2 = (void (*)(float))jarg2;
51026   {
51027     try {
51028       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
51029     } catch (std::out_of_range& e) {
51030       {
51031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51032       };
51033     } catch (std::exception& e) {
51034       {
51035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51036       };
51037     } catch (Dali::DaliException e) {
51038       {
51039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51040       };
51041     } catch (...) {
51042       {
51043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51044       };
51045     }
51046   }
51047
51048 }
51049
51050
51051 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
51052   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51053   float arg2 ;
51054
51055   arg1 = (Dali::Signal< void (float) > *)jarg1;
51056   arg2 = (float)jarg2;
51057   {
51058     try {
51059       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
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_new_FloatSignal() {
51083   void * jresult ;
51084   Dali::Signal< void (float) > *result = 0 ;
51085
51086   {
51087     try {
51088       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
51089     } catch (std::out_of_range& e) {
51090       {
51091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51092       };
51093     } catch (std::exception& e) {
51094       {
51095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51096       };
51097     } catch (Dali::DaliException e) {
51098       {
51099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51100       };
51101     } catch (...) {
51102       {
51103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51104       };
51105     }
51106   }
51107
51108   jresult = (void *)result;
51109   return jresult;
51110 }
51111
51112
51113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
51114   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
51115
51116   arg1 = (Dali::Signal< void (float) > *)jarg1;
51117   {
51118     try {
51119       delete arg1;
51120     } catch (std::out_of_range& e) {
51121       {
51122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51123       };
51124     } catch (std::exception& e) {
51125       {
51126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51127       };
51128     } catch (Dali::DaliException e) {
51129       {
51130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51131       };
51132     } catch (...) {
51133       {
51134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51135       };
51136     }
51137   }
51138
51139 }
51140
51141
51142 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
51143   unsigned int jresult ;
51144   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51145   bool result;
51146
51147   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51148   {
51149     try {
51150       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51151     } catch (std::out_of_range& e) {
51152       {
51153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51154       };
51155     } catch (std::exception& e) {
51156       {
51157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51158       };
51159     } catch (Dali::DaliException e) {
51160       {
51161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51162       };
51163     } catch (...) {
51164       {
51165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51166       };
51167     }
51168   }
51169
51170   jresult = result;
51171   return jresult;
51172 }
51173
51174
51175 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
51176   unsigned long jresult ;
51177   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51178   std::size_t result;
51179
51180   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51181   {
51182     try {
51183       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
51184     } catch (std::out_of_range& e) {
51185       {
51186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51187       };
51188     } catch (std::exception& e) {
51189       {
51190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51191       };
51192     } catch (Dali::DaliException e) {
51193       {
51194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51195       };
51196     } catch (...) {
51197       {
51198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51199       };
51200     }
51201   }
51202
51203   jresult = (unsigned long)result;
51204   return jresult;
51205 }
51206
51207
51208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
51209   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51210   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51211
51212   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51213   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51214   {
51215     try {
51216       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
51217     } catch (std::out_of_range& e) {
51218       {
51219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51220       };
51221     } catch (std::exception& e) {
51222       {
51223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51224       };
51225     } catch (Dali::DaliException e) {
51226       {
51227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51228       };
51229     } catch (...) {
51230       {
51231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51232       };
51233     }
51234   }
51235
51236 }
51237
51238
51239 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
51240   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51241   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
51242
51243   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51244   arg2 = (void (*)(Dali::BaseHandle))jarg2;
51245   {
51246     try {
51247       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
51248     } catch (std::out_of_range& e) {
51249       {
51250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51251       };
51252     } catch (std::exception& e) {
51253       {
51254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51255       };
51256     } catch (Dali::DaliException e) {
51257       {
51258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51259       };
51260     } catch (...) {
51261       {
51262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51263       };
51264     }
51265   }
51266
51267 }
51268
51269
51270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
51271   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51272   Dali::BaseHandle arg2 ;
51273   Dali::BaseHandle *argp2 ;
51274
51275   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51276   argp2 = (Dali::BaseHandle *)jarg2;
51277   if (!argp2) {
51278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
51279     return ;
51280   }
51281   arg2 = *argp2;
51282   {
51283     try {
51284       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
51285     } catch (std::out_of_range& e) {
51286       {
51287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51288       };
51289     } catch (std::exception& e) {
51290       {
51291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51292       };
51293     } catch (Dali::DaliException e) {
51294       {
51295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51296       };
51297     } catch (...) {
51298       {
51299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51300       };
51301     }
51302   }
51303
51304 }
51305
51306
51307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
51308   void * jresult ;
51309   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
51310
51311   {
51312     try {
51313       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
51314     } catch (std::out_of_range& e) {
51315       {
51316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51317       };
51318     } catch (std::exception& e) {
51319       {
51320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51321       };
51322     } catch (Dali::DaliException e) {
51323       {
51324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51325       };
51326     } catch (...) {
51327       {
51328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51329       };
51330     }
51331   }
51332
51333   jresult = (void *)result;
51334   return jresult;
51335 }
51336
51337
51338 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
51339   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
51340
51341   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
51342   {
51343     try {
51344       delete arg1;
51345     } catch (std::out_of_range& e) {
51346       {
51347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51348       };
51349     } catch (std::exception& e) {
51350       {
51351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51352       };
51353     } catch (Dali::DaliException e) {
51354       {
51355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51356       };
51357     } catch (...) {
51358       {
51359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51360       };
51361     }
51362   }
51363
51364 }
51365
51366
51367 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
51368   unsigned int jresult ;
51369   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51370   bool result;
51371
51372   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51373   {
51374     try {
51375       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51376     } catch (std::out_of_range& e) {
51377       {
51378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51379       };
51380     } catch (std::exception& e) {
51381       {
51382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51383       };
51384     } catch (Dali::DaliException e) {
51385       {
51386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51387       };
51388     } catch (...) {
51389       {
51390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51391       };
51392     }
51393   }
51394
51395   jresult = result;
51396   return jresult;
51397 }
51398
51399
51400 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
51401   unsigned long jresult ;
51402   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51403   std::size_t result;
51404
51405   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51406   {
51407     try {
51408       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
51409     } catch (std::out_of_range& e) {
51410       {
51411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51412       };
51413     } catch (std::exception& e) {
51414       {
51415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51416       };
51417     } catch (Dali::DaliException e) {
51418       {
51419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51420       };
51421     } catch (...) {
51422       {
51423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51424       };
51425     }
51426   }
51427
51428   jresult = (unsigned long)result;
51429   return jresult;
51430 }
51431
51432
51433 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
51434   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51435   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51436
51437   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51438   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51439   {
51440     try {
51441       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
51442     } catch (std::out_of_range& e) {
51443       {
51444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51445       };
51446     } catch (std::exception& e) {
51447       {
51448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51449       };
51450     } catch (Dali::DaliException e) {
51451       {
51452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51453       };
51454     } catch (...) {
51455       {
51456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51457       };
51458     }
51459   }
51460
51461 }
51462
51463
51464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
51465   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51466   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
51467
51468   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51469   arg2 = (void (*)(Dali::RefObject const *))jarg2;
51470   {
51471     try {
51472       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
51473     } catch (std::out_of_range& e) {
51474       {
51475         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51476       };
51477     } catch (std::exception& e) {
51478       {
51479         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51480       };
51481     } catch (Dali::DaliException e) {
51482       {
51483         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51484       };
51485     } catch (...) {
51486       {
51487         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51488       };
51489     }
51490   }
51491
51492 }
51493
51494
51495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51496   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51497   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51498
51499   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51500   arg2 = (Dali::RefObject *)jarg2;
51501   {
51502     try {
51503       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51504     } catch (std::out_of_range& e) {
51505       {
51506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51507       };
51508     } catch (std::exception& e) {
51509       {
51510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51511       };
51512     } catch (Dali::DaliException e) {
51513       {
51514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51515       };
51516     } catch (...) {
51517       {
51518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51519       };
51520     }
51521   }
51522
51523 }
51524
51525
51526 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51527   void * jresult ;
51528   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51529
51530   {
51531     try {
51532       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51533     } catch (std::out_of_range& e) {
51534       {
51535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51536       };
51537     } catch (std::exception& e) {
51538       {
51539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51540       };
51541     } catch (Dali::DaliException e) {
51542       {
51543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51544       };
51545     } catch (...) {
51546       {
51547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51548       };
51549     }
51550   }
51551
51552   jresult = (void *)result;
51553   return jresult;
51554 }
51555
51556
51557 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51558   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51559
51560   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51561   {
51562     try {
51563       delete arg1;
51564     } catch (std::out_of_range& e) {
51565       {
51566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51567       };
51568     } catch (std::exception& e) {
51569       {
51570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51571       };
51572     } catch (Dali::DaliException e) {
51573       {
51574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51575       };
51576     } catch (...) {
51577       {
51578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51579       };
51580     }
51581   }
51582
51583 }
51584
51585
51586 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51587   unsigned int jresult ;
51588   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51589   bool result;
51590
51591   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51592   {
51593     try {
51594       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51595     } catch (std::out_of_range& e) {
51596       {
51597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51598       };
51599     } catch (std::exception& e) {
51600       {
51601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51602       };
51603     } catch (Dali::DaliException e) {
51604       {
51605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51606       };
51607     } catch (...) {
51608       {
51609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51610       };
51611     }
51612   }
51613
51614   jresult = result;
51615   return jresult;
51616 }
51617
51618
51619 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51620   unsigned long jresult ;
51621   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51622   std::size_t result;
51623
51624   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51625   {
51626     try {
51627       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51628     } catch (std::out_of_range& e) {
51629       {
51630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51631       };
51632     } catch (std::exception& e) {
51633       {
51634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51635       };
51636     } catch (Dali::DaliException e) {
51637       {
51638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51639       };
51640     } catch (...) {
51641       {
51642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51643       };
51644     }
51645   }
51646
51647   jresult = (unsigned long)result;
51648   return jresult;
51649 }
51650
51651
51652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51653   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51654   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51655
51656   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51657   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51658   {
51659     try {
51660       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51661     } catch (std::out_of_range& e) {
51662       {
51663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51664       };
51665     } catch (std::exception& e) {
51666       {
51667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51668       };
51669     } catch (Dali::DaliException e) {
51670       {
51671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51672       };
51673     } catch (...) {
51674       {
51675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51676       };
51677     }
51678   }
51679
51680 }
51681
51682
51683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51684   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51685   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51686
51687   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51688   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51689   {
51690     try {
51691       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51692     } catch (std::out_of_range& e) {
51693       {
51694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51695       };
51696     } catch (std::exception& e) {
51697       {
51698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51699       };
51700     } catch (Dali::DaliException e) {
51701       {
51702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51703       };
51704     } catch (...) {
51705       {
51706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51707       };
51708     }
51709   }
51710
51711 }
51712
51713
51714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51715   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51716   Dali::PropertyNotification *arg2 = 0 ;
51717
51718   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51719   arg2 = (Dali::PropertyNotification *)jarg2;
51720   if (!arg2) {
51721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51722     return ;
51723   }
51724   {
51725     try {
51726       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51727     } catch (std::out_of_range& e) {
51728       {
51729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51730       };
51731     } catch (std::exception& e) {
51732       {
51733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51734       };
51735     } catch (Dali::DaliException e) {
51736       {
51737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51738       };
51739     } catch (...) {
51740       {
51741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51742       };
51743     }
51744   }
51745
51746 }
51747
51748
51749 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51750   void * jresult ;
51751   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51752
51753   {
51754     try {
51755       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51756     } catch (std::out_of_range& e) {
51757       {
51758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51759       };
51760     } catch (std::exception& e) {
51761       {
51762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51763       };
51764     } catch (Dali::DaliException e) {
51765       {
51766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51767       };
51768     } catch (...) {
51769       {
51770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51771       };
51772     }
51773   }
51774
51775   jresult = (void *)result;
51776   return jresult;
51777 }
51778
51779
51780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51781   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51782
51783   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51784   {
51785     try {
51786       delete arg1;
51787     } catch (std::out_of_range& e) {
51788       {
51789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51790       };
51791     } catch (std::exception& e) {
51792       {
51793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51794       };
51795     } catch (Dali::DaliException e) {
51796       {
51797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51798       };
51799     } catch (...) {
51800       {
51801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51802       };
51803     }
51804   }
51805
51806 }
51807
51808
51809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51810   void * jresult ;
51811   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51812
51813   {
51814     try {
51815       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51816     } catch (std::out_of_range& e) {
51817       {
51818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51819       };
51820     } catch (std::exception& e) {
51821       {
51822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51823       };
51824     } catch (Dali::DaliException e) {
51825       {
51826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51827       };
51828     } catch (...) {
51829       {
51830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51831       };
51832     }
51833   }
51834
51835   jresult = (void *)result;
51836   return jresult;
51837 }
51838
51839
51840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51841   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51842
51843   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51844   {
51845     try {
51846       delete arg1;
51847     } catch (std::out_of_range& e) {
51848       {
51849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51850       };
51851     } catch (std::exception& e) {
51852       {
51853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51854       };
51855     } catch (Dali::DaliException e) {
51856       {
51857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51858       };
51859     } catch (...) {
51860       {
51861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51862       };
51863     }
51864   }
51865
51866 }
51867
51868
51869 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51870   unsigned int jresult ;
51871   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51872   bool result;
51873
51874   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51875   {
51876     try {
51877       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);
51878     } catch (std::out_of_range& e) {
51879       {
51880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51881       };
51882     } catch (std::exception& e) {
51883       {
51884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51885       };
51886     } catch (Dali::DaliException e) {
51887       {
51888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51889       };
51890     } catch (...) {
51891       {
51892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51893       };
51894     }
51895   }
51896
51897   jresult = result;
51898   return jresult;
51899 }
51900
51901
51902 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51903   unsigned long jresult ;
51904   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51905   std::size_t result;
51906
51907   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51908   {
51909     try {
51910       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);
51911     } catch (std::out_of_range& e) {
51912       {
51913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51914       };
51915     } catch (std::exception& e) {
51916       {
51917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51918       };
51919     } catch (Dali::DaliException e) {
51920       {
51921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51922       };
51923     } catch (...) {
51924       {
51925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51926       };
51927     }
51928   }
51929
51930   jresult = (unsigned long)result;
51931   return jresult;
51932 }
51933
51934
51935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51936   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51937   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51938
51939   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51940   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51941   {
51942     try {
51943       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51944     } catch (std::out_of_range& e) {
51945       {
51946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51947       };
51948     } catch (std::exception& e) {
51949       {
51950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51951       };
51952     } catch (Dali::DaliException e) {
51953       {
51954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51955       };
51956     } catch (...) {
51957       {
51958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51959       };
51960     }
51961   }
51962
51963 }
51964
51965
51966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51967   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51968   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51969
51970   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51971   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51972   {
51973     try {
51974       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51975     } catch (std::out_of_range& e) {
51976       {
51977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51978       };
51979     } catch (std::exception& e) {
51980       {
51981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51982       };
51983     } catch (Dali::DaliException e) {
51984       {
51985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51986       };
51987     } catch (...) {
51988       {
51989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51990       };
51991     }
51992   }
51993
51994 }
51995
51996
51997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51998   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51999   Dali::Actor arg2 ;
52000   Dali::LongPressGesture *arg3 = 0 ;
52001   Dali::Actor *argp2 ;
52002
52003   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52004   argp2 = (Dali::Actor *)jarg2;
52005   if (!argp2) {
52006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52007     return ;
52008   }
52009   arg2 = *argp2;
52010   arg3 = (Dali::LongPressGesture *)jarg3;
52011   if (!arg3) {
52012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
52013     return ;
52014   }
52015   {
52016     try {
52017       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
52018     } catch (std::out_of_range& e) {
52019       {
52020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52021       };
52022     } catch (std::exception& e) {
52023       {
52024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52025       };
52026     } catch (Dali::DaliException e) {
52027       {
52028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52029       };
52030     } catch (...) {
52031       {
52032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52033       };
52034     }
52035   }
52036
52037 }
52038
52039
52040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
52041   void * jresult ;
52042   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
52043
52044   {
52045     try {
52046       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
52047     } catch (std::out_of_range& e) {
52048       {
52049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52050       };
52051     } catch (std::exception& e) {
52052       {
52053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52054       };
52055     } catch (Dali::DaliException e) {
52056       {
52057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52058       };
52059     } catch (...) {
52060       {
52061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52062       };
52063     }
52064   }
52065
52066   jresult = (void *)result;
52067   return jresult;
52068 }
52069
52070
52071 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
52072   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
52073
52074   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
52075   {
52076     try {
52077       delete arg1;
52078     } catch (std::out_of_range& e) {
52079       {
52080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52081       };
52082     } catch (std::exception& e) {
52083       {
52084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52085       };
52086     } catch (Dali::DaliException e) {
52087       {
52088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52089       };
52090     } catch (...) {
52091       {
52092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52093       };
52094     }
52095   }
52096
52097 }
52098
52099
52100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
52101   unsigned int jresult ;
52102   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52103   bool result;
52104
52105   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52106   {
52107     try {
52108       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);
52109     } catch (std::out_of_range& e) {
52110       {
52111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52112       };
52113     } catch (std::exception& e) {
52114       {
52115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52116       };
52117     } catch (Dali::DaliException e) {
52118       {
52119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52120       };
52121     } catch (...) {
52122       {
52123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52124       };
52125     }
52126   }
52127
52128   jresult = result;
52129   return jresult;
52130 }
52131
52132
52133 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
52134   unsigned long jresult ;
52135   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52136   std::size_t result;
52137
52138   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52139   {
52140     try {
52141       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);
52142     } catch (std::out_of_range& e) {
52143       {
52144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52145       };
52146     } catch (std::exception& e) {
52147       {
52148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52149       };
52150     } catch (Dali::DaliException e) {
52151       {
52152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52153       };
52154     } catch (...) {
52155       {
52156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52157       };
52158     }
52159   }
52160
52161   jresult = (unsigned long)result;
52162   return jresult;
52163 }
52164
52165
52166 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
52167   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52168   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
52169
52170   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52171   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
52172   {
52173     try {
52174       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52175     } catch (std::out_of_range& e) {
52176       {
52177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52178       };
52179     } catch (std::exception& e) {
52180       {
52181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52182       };
52183     } catch (Dali::DaliException e) {
52184       {
52185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52186       };
52187     } catch (...) {
52188       {
52189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52190       };
52191     }
52192   }
52193
52194 }
52195
52196
52197 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
52198   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52199   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
52200
52201   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52202   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
52203   {
52204     try {
52205       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52206     } catch (std::out_of_range& e) {
52207       {
52208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52209       };
52210     } catch (std::exception& e) {
52211       {
52212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52213       };
52214     } catch (Dali::DaliException e) {
52215       {
52216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52217       };
52218     } catch (...) {
52219       {
52220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52221       };
52222     }
52223   }
52224
52225 }
52226
52227
52228 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52229   unsigned int jresult ;
52230   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52231   Dali::Actor arg2 ;
52232   Dali::TouchData *arg3 = 0 ;
52233   Dali::Actor *argp2 ;
52234   bool result;
52235
52236   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52237   argp2 = (Dali::Actor *)jarg2;
52238   if (!argp2) {
52239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52240     return 0;
52241   }
52242   arg2 = *argp2;
52243   arg3 = (Dali::TouchData *)jarg3;
52244   if (!arg3) {
52245     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52246     return 0;
52247   }
52248   {
52249     try {
52250       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
52251     } catch (std::out_of_range& e) {
52252       {
52253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52254       };
52255     } catch (std::exception& e) {
52256       {
52257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52258       };
52259     } catch (Dali::DaliException e) {
52260       {
52261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52262       };
52263     } catch (...) {
52264       {
52265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52266       };
52267     }
52268   }
52269
52270   jresult = result;
52271   return jresult;
52272 }
52273
52274
52275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
52276   void * jresult ;
52277   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
52278
52279   {
52280     try {
52281       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
52282     } catch (std::out_of_range& e) {
52283       {
52284         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52285       };
52286     } catch (std::exception& e) {
52287       {
52288         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52289       };
52290     } catch (Dali::DaliException e) {
52291       {
52292         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52293       };
52294     } catch (...) {
52295       {
52296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52297       };
52298     }
52299   }
52300
52301   jresult = (void *)result;
52302   return jresult;
52303 }
52304
52305
52306 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
52307   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
52308
52309   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
52310   {
52311     try {
52312       delete arg1;
52313     } catch (std::out_of_range& e) {
52314       {
52315         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52316       };
52317     } catch (std::exception& e) {
52318       {
52319         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52320       };
52321     } catch (Dali::DaliException e) {
52322       {
52323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52324       };
52325     } catch (...) {
52326       {
52327         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52328       };
52329     }
52330   }
52331
52332 }
52333
52334
52335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
52336   unsigned int jresult ;
52337   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52338   bool result;
52339
52340   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52341   {
52342     try {
52343       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);
52344     } catch (std::out_of_range& e) {
52345       {
52346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52347       };
52348     } catch (std::exception& e) {
52349       {
52350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52351       };
52352     } catch (Dali::DaliException e) {
52353       {
52354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52355       };
52356     } catch (...) {
52357       {
52358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52359       };
52360     }
52361   }
52362
52363   jresult = result;
52364   return jresult;
52365 }
52366
52367
52368 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
52369   unsigned long jresult ;
52370   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52371   std::size_t result;
52372
52373   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52374   {
52375     try {
52376       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);
52377     } catch (std::out_of_range& e) {
52378       {
52379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52380       };
52381     } catch (std::exception& e) {
52382       {
52383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52384       };
52385     } catch (Dali::DaliException e) {
52386       {
52387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52388       };
52389     } catch (...) {
52390       {
52391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52392       };
52393     }
52394   }
52395
52396   jresult = (unsigned long)result;
52397   return jresult;
52398 }
52399
52400
52401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
52402   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52403   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52404
52405   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52406   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52407   {
52408     try {
52409       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52410     } catch (std::out_of_range& e) {
52411       {
52412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52413       };
52414     } catch (std::exception& e) {
52415       {
52416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52417       };
52418     } catch (Dali::DaliException e) {
52419       {
52420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52421       };
52422     } catch (...) {
52423       {
52424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52425       };
52426     }
52427   }
52428
52429 }
52430
52431
52432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
52433   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52434   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
52435
52436   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52437   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
52438   {
52439     try {
52440       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52441     } catch (std::out_of_range& e) {
52442       {
52443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52444       };
52445     } catch (std::exception& e) {
52446       {
52447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52448       };
52449     } catch (Dali::DaliException e) {
52450       {
52451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52452       };
52453     } catch (...) {
52454       {
52455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52456       };
52457     }
52458   }
52459
52460 }
52461
52462
52463 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52464   unsigned int jresult ;
52465   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52466   Dali::Actor arg2 ;
52467   Dali::HoverEvent *arg3 = 0 ;
52468   Dali::Actor *argp2 ;
52469   bool result;
52470
52471   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52472   argp2 = (Dali::Actor *)jarg2;
52473   if (!argp2) {
52474     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52475     return 0;
52476   }
52477   arg2 = *argp2;
52478   arg3 = (Dali::HoverEvent *)jarg3;
52479   if (!arg3) {
52480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
52481     return 0;
52482   }
52483   {
52484     try {
52485       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
52486     } catch (std::out_of_range& e) {
52487       {
52488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52489       };
52490     } catch (std::exception& e) {
52491       {
52492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52493       };
52494     } catch (Dali::DaliException e) {
52495       {
52496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52497       };
52498     } catch (...) {
52499       {
52500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52501       };
52502     }
52503   }
52504
52505   jresult = result;
52506   return jresult;
52507 }
52508
52509
52510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52511   void * jresult ;
52512   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52513
52514   {
52515     try {
52516       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52517     } catch (std::out_of_range& e) {
52518       {
52519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52520       };
52521     } catch (std::exception& e) {
52522       {
52523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52524       };
52525     } catch (Dali::DaliException e) {
52526       {
52527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52528       };
52529     } catch (...) {
52530       {
52531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52532       };
52533     }
52534   }
52535
52536   jresult = (void *)result;
52537   return jresult;
52538 }
52539
52540
52541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52542   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52543
52544   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52545   {
52546     try {
52547       delete arg1;
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 unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52571   unsigned int jresult ;
52572   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52573   bool result;
52574
52575   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52576   {
52577     try {
52578       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);
52579     } catch (std::out_of_range& e) {
52580       {
52581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52582       };
52583     } catch (std::exception& e) {
52584       {
52585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52586       };
52587     } catch (Dali::DaliException e) {
52588       {
52589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52590       };
52591     } catch (...) {
52592       {
52593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52594       };
52595     }
52596   }
52597
52598   jresult = result;
52599   return jresult;
52600 }
52601
52602
52603 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52604   unsigned long jresult ;
52605   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52606   std::size_t result;
52607
52608   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52609   {
52610     try {
52611       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);
52612     } catch (std::out_of_range& e) {
52613       {
52614         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52615       };
52616     } catch (std::exception& e) {
52617       {
52618         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52619       };
52620     } catch (Dali::DaliException e) {
52621       {
52622         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52623       };
52624     } catch (...) {
52625       {
52626         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52627       };
52628     }
52629   }
52630
52631   jresult = (unsigned long)result;
52632   return jresult;
52633 }
52634
52635
52636 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52637   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52638   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52639
52640   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52641   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52642   {
52643     try {
52644       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52645     } catch (std::out_of_range& e) {
52646       {
52647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52648       };
52649     } catch (std::exception& e) {
52650       {
52651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52652       };
52653     } catch (Dali::DaliException e) {
52654       {
52655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52656       };
52657     } catch (...) {
52658       {
52659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52660       };
52661     }
52662   }
52663
52664 }
52665
52666
52667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52668   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52669   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52670
52671   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52672   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52673   {
52674     try {
52675       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52676     } catch (std::out_of_range& e) {
52677       {
52678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52679       };
52680     } catch (std::exception& e) {
52681       {
52682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52683       };
52684     } catch (Dali::DaliException e) {
52685       {
52686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52687       };
52688     } catch (...) {
52689       {
52690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52691       };
52692     }
52693   }
52694
52695 }
52696
52697
52698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52699   unsigned int jresult ;
52700   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52701   Dali::Actor arg2 ;
52702   Dali::WheelEvent *arg3 = 0 ;
52703   Dali::Actor *argp2 ;
52704   bool result;
52705
52706   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52707   argp2 = (Dali::Actor *)jarg2;
52708   if (!argp2) {
52709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52710     return 0;
52711   }
52712   arg2 = *argp2;
52713   arg3 = (Dali::WheelEvent *)jarg3;
52714   if (!arg3) {
52715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52716     return 0;
52717   }
52718   {
52719     try {
52720       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52721     } catch (std::out_of_range& e) {
52722       {
52723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52724       };
52725     } catch (std::exception& e) {
52726       {
52727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52728       };
52729     } catch (Dali::DaliException e) {
52730       {
52731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52732       };
52733     } catch (...) {
52734       {
52735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52736       };
52737     }
52738   }
52739
52740   jresult = result;
52741   return jresult;
52742 }
52743
52744
52745 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52746   void * jresult ;
52747   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52748
52749   {
52750     try {
52751       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52752     } catch (std::out_of_range& e) {
52753       {
52754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52755       };
52756     } catch (std::exception& e) {
52757       {
52758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52759       };
52760     } catch (Dali::DaliException e) {
52761       {
52762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52763       };
52764     } catch (...) {
52765       {
52766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52767       };
52768     }
52769   }
52770
52771   jresult = (void *)result;
52772   return jresult;
52773 }
52774
52775
52776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52777   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52778
52779   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52780   {
52781     try {
52782       delete arg1;
52783     } catch (std::out_of_range& e) {
52784       {
52785         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52786       };
52787     } catch (std::exception& e) {
52788       {
52789         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52790       };
52791     } catch (Dali::DaliException e) {
52792       {
52793         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52794       };
52795     } catch (...) {
52796       {
52797         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52798       };
52799     }
52800   }
52801
52802 }
52803
52804
52805 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52806   unsigned int jresult ;
52807   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52808   bool result;
52809
52810   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52811   {
52812     try {
52813       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52814     } catch (std::out_of_range& e) {
52815       {
52816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52817       };
52818     } catch (std::exception& e) {
52819       {
52820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52821       };
52822     } catch (Dali::DaliException e) {
52823       {
52824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52825       };
52826     } catch (...) {
52827       {
52828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52829       };
52830     }
52831   }
52832
52833   jresult = result;
52834   return jresult;
52835 }
52836
52837
52838 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52839   unsigned long jresult ;
52840   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52841   std::size_t result;
52842
52843   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52844   {
52845     try {
52846       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52847     } catch (std::out_of_range& e) {
52848       {
52849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52850       };
52851     } catch (std::exception& e) {
52852       {
52853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52854       };
52855     } catch (Dali::DaliException e) {
52856       {
52857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52858       };
52859     } catch (...) {
52860       {
52861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52862       };
52863     }
52864   }
52865
52866   jresult = (unsigned long)result;
52867   return jresult;
52868 }
52869
52870
52871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52872   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52873   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52874
52875   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52876   arg2 = (void (*)(Dali::Actor))jarg2;
52877   {
52878     try {
52879       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52880     } catch (std::out_of_range& e) {
52881       {
52882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52883       };
52884     } catch (std::exception& e) {
52885       {
52886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52887       };
52888     } catch (Dali::DaliException e) {
52889       {
52890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52891       };
52892     } catch (...) {
52893       {
52894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52895       };
52896     }
52897   }
52898
52899 }
52900
52901
52902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52903   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52904   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52905
52906   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52907   arg2 = (void (*)(Dali::Actor))jarg2;
52908   {
52909     try {
52910       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52911     } catch (std::out_of_range& e) {
52912       {
52913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52914       };
52915     } catch (std::exception& e) {
52916       {
52917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52918       };
52919     } catch (Dali::DaliException e) {
52920       {
52921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52922       };
52923     } catch (...) {
52924       {
52925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52926       };
52927     }
52928   }
52929
52930 }
52931
52932
52933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52934   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52935   Dali::Actor arg2 ;
52936   Dali::Actor *argp2 ;
52937
52938   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52939   argp2 = (Dali::Actor *)jarg2;
52940   if (!argp2) {
52941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52942     return ;
52943   }
52944   arg2 = *argp2;
52945   {
52946     try {
52947       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52948     } catch (std::out_of_range& e) {
52949       {
52950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52951       };
52952     } catch (std::exception& e) {
52953       {
52954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52955       };
52956     } catch (Dali::DaliException e) {
52957       {
52958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52959       };
52960     } catch (...) {
52961       {
52962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52963       };
52964     }
52965   }
52966
52967 }
52968
52969
52970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52971   void * jresult ;
52972   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52973
52974   {
52975     try {
52976       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52977     } catch (std::out_of_range& e) {
52978       {
52979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52980       };
52981     } catch (std::exception& e) {
52982       {
52983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52984       };
52985     } catch (Dali::DaliException e) {
52986       {
52987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52988       };
52989     } catch (...) {
52990       {
52991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52992       };
52993     }
52994   }
52995
52996   jresult = (void *)result;
52997   return jresult;
52998 }
52999
53000
53001 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
53002   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
53003
53004   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
53005   {
53006     try {
53007       delete arg1;
53008     } catch (std::out_of_range& e) {
53009       {
53010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53011       };
53012     } catch (std::exception& e) {
53013       {
53014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53015       };
53016     } catch (Dali::DaliException e) {
53017       {
53018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53019       };
53020     } catch (...) {
53021       {
53022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53023       };
53024     }
53025   }
53026
53027 }
53028
53029
53030 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
53031   unsigned int jresult ;
53032   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53033   bool result;
53034
53035   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53036   {
53037     try {
53038       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53039     } catch (std::out_of_range& e) {
53040       {
53041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53042       };
53043     } catch (std::exception& e) {
53044       {
53045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53046       };
53047     } catch (Dali::DaliException e) {
53048       {
53049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53050       };
53051     } catch (...) {
53052       {
53053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53054       };
53055     }
53056   }
53057
53058   jresult = result;
53059   return jresult;
53060 }
53061
53062
53063 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
53064   unsigned long jresult ;
53065   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53066   std::size_t result;
53067
53068   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53069   {
53070     try {
53071       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
53072     } catch (std::out_of_range& e) {
53073       {
53074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53075       };
53076     } catch (std::exception& e) {
53077       {
53078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53079       };
53080     } catch (Dali::DaliException e) {
53081       {
53082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53083       };
53084     } catch (...) {
53085       {
53086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53087       };
53088     }
53089   }
53090
53091   jresult = (unsigned long)result;
53092   return jresult;
53093 }
53094
53095
53096 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
53097   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53098   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53099
53100   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53101   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53102   {
53103     try {
53104       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53105     } catch (std::out_of_range& e) {
53106       {
53107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53108       };
53109     } catch (std::exception& e) {
53110       {
53111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53112       };
53113     } catch (Dali::DaliException e) {
53114       {
53115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53116       };
53117     } catch (...) {
53118       {
53119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53120       };
53121     }
53122   }
53123
53124 }
53125
53126
53127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
53128   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53129   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
53130
53131   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53132   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
53133   {
53134     try {
53135       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53136     } catch (std::out_of_range& e) {
53137       {
53138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53139       };
53140     } catch (std::exception& e) {
53141       {
53142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53143       };
53144     } catch (Dali::DaliException e) {
53145       {
53146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53147       };
53148     } catch (...) {
53149       {
53150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53151       };
53152     }
53153   }
53154
53155 }
53156
53157
53158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
53159   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53160   Dali::KeyEvent *arg2 = 0 ;
53161
53162   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53163   arg2 = (Dali::KeyEvent *)jarg2;
53164   if (!arg2) {
53165     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
53166     return ;
53167   }
53168   {
53169     try {
53170       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
53171     } catch (std::out_of_range& e) {
53172       {
53173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53174       };
53175     } catch (std::exception& e) {
53176       {
53177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53178       };
53179     } catch (Dali::DaliException e) {
53180       {
53181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53182       };
53183     } catch (...) {
53184       {
53185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53186       };
53187     }
53188   }
53189
53190 }
53191
53192
53193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
53194   void * jresult ;
53195   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
53196
53197   {
53198     try {
53199       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
53200     } catch (std::out_of_range& e) {
53201       {
53202         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53203       };
53204     } catch (std::exception& e) {
53205       {
53206         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53207       };
53208     } catch (Dali::DaliException e) {
53209       {
53210         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53211       };
53212     } catch (...) {
53213       {
53214         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53215       };
53216     }
53217   }
53218
53219   jresult = (void *)result;
53220   return jresult;
53221 }
53222
53223
53224 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
53225   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
53226
53227   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
53228   {
53229     try {
53230       delete arg1;
53231     } catch (std::out_of_range& e) {
53232       {
53233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53234       };
53235     } catch (std::exception& e) {
53236       {
53237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53238       };
53239     } catch (Dali::DaliException e) {
53240       {
53241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53242       };
53243     } catch (...) {
53244       {
53245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53246       };
53247     }
53248   }
53249
53250 }
53251
53252
53253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
53254   unsigned int jresult ;
53255   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53256   bool result;
53257
53258   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53259   {
53260     try {
53261       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
53262     } catch (std::out_of_range& e) {
53263       {
53264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53265       };
53266     } catch (std::exception& e) {
53267       {
53268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53269       };
53270     } catch (Dali::DaliException e) {
53271       {
53272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53273       };
53274     } catch (...) {
53275       {
53276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53277       };
53278     }
53279   }
53280
53281   jresult = result;
53282   return jresult;
53283 }
53284
53285
53286 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
53287   unsigned long jresult ;
53288   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53289   std::size_t result;
53290
53291   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53292   {
53293     try {
53294       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
53295     } catch (std::out_of_range& e) {
53296       {
53297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53298       };
53299     } catch (std::exception& e) {
53300       {
53301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53302       };
53303     } catch (Dali::DaliException e) {
53304       {
53305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53306       };
53307     } catch (...) {
53308       {
53309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53310       };
53311     }
53312   }
53313
53314   jresult = (unsigned long)result;
53315   return jresult;
53316 }
53317
53318
53319 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
53320   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53321   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
53322
53323   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53324   arg2 = (void (*)(Dali::TouchData const &))jarg2;
53325   {
53326     try {
53327       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53328     } catch (std::out_of_range& e) {
53329       {
53330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53331       };
53332     } catch (std::exception& e) {
53333       {
53334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53335       };
53336     } catch (Dali::DaliException e) {
53337       {
53338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53339       };
53340     } catch (...) {
53341       {
53342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53343       };
53344     }
53345   }
53346
53347 }
53348
53349
53350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
53351   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53352   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
53353
53354   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53355   arg2 = (void (*)(Dali::TouchData const &))jarg2;
53356   {
53357     try {
53358       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53359     } catch (std::out_of_range& e) {
53360       {
53361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53362       };
53363     } catch (std::exception& e) {
53364       {
53365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53366       };
53367     } catch (Dali::DaliException e) {
53368       {
53369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53370       };
53371     } catch (...) {
53372       {
53373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53374       };
53375     }
53376   }
53377
53378 }
53379
53380
53381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
53382   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53383   Dali::TouchData *arg2 = 0 ;
53384
53385   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53386   arg2 = (Dali::TouchData *)jarg2;
53387   if (!arg2) {
53388     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
53389     return ;
53390   }
53391   {
53392     try {
53393       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
53394     } catch (std::out_of_range& e) {
53395       {
53396         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53397       };
53398     } catch (std::exception& e) {
53399       {
53400         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53401       };
53402     } catch (Dali::DaliException e) {
53403       {
53404         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53405       };
53406     } catch (...) {
53407       {
53408         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53409       };
53410     }
53411   }
53412
53413 }
53414
53415
53416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
53417   void * jresult ;
53418   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
53419
53420   {
53421     try {
53422       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
53423     } catch (std::out_of_range& e) {
53424       {
53425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53426       };
53427     } catch (std::exception& e) {
53428       {
53429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53430       };
53431     } catch (Dali::DaliException e) {
53432       {
53433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53434       };
53435     } catch (...) {
53436       {
53437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53438       };
53439     }
53440   }
53441
53442   jresult = (void *)result;
53443   return jresult;
53444 }
53445
53446
53447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
53448   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
53449
53450   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
53451   {
53452     try {
53453       delete arg1;
53454     } catch (std::out_of_range& e) {
53455       {
53456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53457       };
53458     } catch (std::exception& e) {
53459       {
53460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53461       };
53462     } catch (Dali::DaliException e) {
53463       {
53464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53465       };
53466     } catch (...) {
53467       {
53468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53469       };
53470     }
53471   }
53472
53473 }
53474
53475
53476 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
53477   unsigned int jresult ;
53478   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53479   bool result;
53480
53481   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53482   {
53483     try {
53484       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53485     } catch (std::out_of_range& e) {
53486       {
53487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53488       };
53489     } catch (std::exception& e) {
53490       {
53491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53492       };
53493     } catch (Dali::DaliException e) {
53494       {
53495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53496       };
53497     } catch (...) {
53498       {
53499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53500       };
53501     }
53502   }
53503
53504   jresult = result;
53505   return jresult;
53506 }
53507
53508
53509 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53510   unsigned long jresult ;
53511   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53512   std::size_t result;
53513
53514   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53515   {
53516     try {
53517       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53518     } catch (std::out_of_range& e) {
53519       {
53520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53521       };
53522     } catch (std::exception& e) {
53523       {
53524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53525       };
53526     } catch (Dali::DaliException e) {
53527       {
53528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53529       };
53530     } catch (...) {
53531       {
53532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53533       };
53534     }
53535   }
53536
53537   jresult = (unsigned long)result;
53538   return jresult;
53539 }
53540
53541
53542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53543   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53544   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53545
53546   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53547   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53548   {
53549     try {
53550       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53551     } catch (std::out_of_range& e) {
53552       {
53553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53554       };
53555     } catch (std::exception& e) {
53556       {
53557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53558       };
53559     } catch (Dali::DaliException e) {
53560       {
53561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53562       };
53563     } catch (...) {
53564       {
53565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53566       };
53567     }
53568   }
53569
53570 }
53571
53572
53573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53574   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53575   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53576
53577   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53578   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53579   {
53580     try {
53581       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53582     } catch (std::out_of_range& e) {
53583       {
53584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53585       };
53586     } catch (std::exception& e) {
53587       {
53588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53589       };
53590     } catch (Dali::DaliException e) {
53591       {
53592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53593       };
53594     } catch (...) {
53595       {
53596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53597       };
53598     }
53599   }
53600
53601 }
53602
53603
53604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53605   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53606   Dali::WheelEvent *arg2 = 0 ;
53607
53608   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53609   arg2 = (Dali::WheelEvent *)jarg2;
53610   if (!arg2) {
53611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53612     return ;
53613   }
53614   {
53615     try {
53616       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53617     } catch (std::out_of_range& e) {
53618       {
53619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53620       };
53621     } catch (std::exception& e) {
53622       {
53623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53624       };
53625     } catch (Dali::DaliException e) {
53626       {
53627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53628       };
53629     } catch (...) {
53630       {
53631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53632       };
53633     }
53634   }
53635
53636 }
53637
53638
53639 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53640   void * jresult ;
53641   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53642
53643   {
53644     try {
53645       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53646     } catch (std::out_of_range& e) {
53647       {
53648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53649       };
53650     } catch (std::exception& e) {
53651       {
53652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53653       };
53654     } catch (Dali::DaliException e) {
53655       {
53656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53657       };
53658     } catch (...) {
53659       {
53660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53661       };
53662     }
53663   }
53664
53665   jresult = (void *)result;
53666   return jresult;
53667 }
53668
53669
53670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53671   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53672
53673   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53674   {
53675     try {
53676       delete arg1;
53677     } catch (std::out_of_range& e) {
53678       {
53679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53680       };
53681     } catch (std::exception& e) {
53682       {
53683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53684       };
53685     } catch (Dali::DaliException e) {
53686       {
53687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53688       };
53689     } catch (...) {
53690       {
53691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53692       };
53693     }
53694   }
53695
53696 }
53697
53698
53699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53700   void * jresult ;
53701   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53702
53703   {
53704     try {
53705       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53706     } catch (std::out_of_range& e) {
53707       {
53708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53709       };
53710     } catch (std::exception& e) {
53711       {
53712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53713       };
53714     } catch (Dali::DaliException e) {
53715       {
53716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53717       };
53718     } catch (...) {
53719       {
53720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53721       };
53722     }
53723   }
53724
53725   jresult = (void *)result;
53726   return jresult;
53727 }
53728
53729
53730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53731   void * jresult ;
53732   Dali::Radian arg1 ;
53733   Dali::Radian arg2 ;
53734   Dali::Radian *argp1 ;
53735   Dali::Radian *argp2 ;
53736   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53737
53738   argp1 = (Dali::Radian *)jarg1;
53739   if (!argp1) {
53740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53741     return 0;
53742   }
53743   arg1 = *argp1;
53744   argp2 = (Dali::Radian *)jarg2;
53745   if (!argp2) {
53746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53747     return 0;
53748   }
53749   arg2 = *argp2;
53750   {
53751     try {
53752       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53753     } catch (std::out_of_range& e) {
53754       {
53755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53756       };
53757     } catch (std::exception& e) {
53758       {
53759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53760       };
53761     } catch (Dali::DaliException e) {
53762       {
53763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53764       };
53765     } catch (...) {
53766       {
53767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53768       };
53769     }
53770   }
53771
53772   jresult = (void *)result;
53773   return jresult;
53774 }
53775
53776
53777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53778   void * jresult ;
53779   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53780   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53781
53782   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53783   if (!arg1) {
53784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53785     return 0;
53786   }
53787   {
53788     try {
53789       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53790     } catch (std::out_of_range& e) {
53791       {
53792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53793       };
53794     } catch (std::exception& e) {
53795       {
53796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53797       };
53798     } catch (Dali::DaliException e) {
53799       {
53800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53801       };
53802     } catch (...) {
53803       {
53804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53805       };
53806     }
53807   }
53808
53809   jresult = (void *)result;
53810   return jresult;
53811 }
53812
53813
53814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53815   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53816   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53817
53818   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53819   arg2 = (Dali::Radian *)jarg2;
53820   if (arg1) (arg1)->first = *arg2;
53821 }
53822
53823
53824 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53825   void * jresult ;
53826   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53827   Dali::Radian *result = 0 ;
53828
53829   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53830   result = (Dali::Radian *)& ((arg1)->first);
53831   jresult = (void *)result;
53832   return jresult;
53833 }
53834
53835
53836 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53837   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53838   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53839
53840   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53841   arg2 = (Dali::Radian *)jarg2;
53842   if (arg1) (arg1)->second = *arg2;
53843 }
53844
53845
53846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53847   void * jresult ;
53848   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53849   Dali::Radian *result = 0 ;
53850
53851   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53852   result = (Dali::Radian *)& ((arg1)->second);
53853   jresult = (void *)result;
53854   return jresult;
53855 }
53856
53857
53858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53859   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53860
53861   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53862   {
53863     try {
53864       delete arg1;
53865     } catch (std::out_of_range& e) {
53866       {
53867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53868       };
53869     } catch (std::exception& e) {
53870       {
53871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53872       };
53873     } catch (Dali::DaliException e) {
53874       {
53875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53876       };
53877     } catch (...) {
53878       {
53879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53880       };
53881     }
53882   }
53883
53884 }
53885
53886
53887 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53888   unsigned int jresult ;
53889   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53890   bool result;
53891
53892   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53893   {
53894     try {
53895       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);
53896     } catch (std::out_of_range& e) {
53897       {
53898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53899       };
53900     } catch (std::exception& e) {
53901       {
53902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53903       };
53904     } catch (Dali::DaliException e) {
53905       {
53906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53907       };
53908     } catch (...) {
53909       {
53910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53911       };
53912     }
53913   }
53914
53915   jresult = result;
53916   return jresult;
53917 }
53918
53919
53920 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53921   unsigned long jresult ;
53922   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53923   std::size_t result;
53924
53925   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53926   {
53927     try {
53928       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);
53929     } catch (std::out_of_range& e) {
53930       {
53931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53932       };
53933     } catch (std::exception& e) {
53934       {
53935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53936       };
53937     } catch (Dali::DaliException e) {
53938       {
53939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53940       };
53941     } catch (...) {
53942       {
53943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53944       };
53945     }
53946   }
53947
53948   jresult = (unsigned long)result;
53949   return jresult;
53950 }
53951
53952
53953 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53954   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53955   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53956
53957   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53958   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53959   {
53960     try {
53961       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53962     } catch (std::out_of_range& e) {
53963       {
53964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53965       };
53966     } catch (std::exception& e) {
53967       {
53968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53969       };
53970     } catch (Dali::DaliException e) {
53971       {
53972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53973       };
53974     } catch (...) {
53975       {
53976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53977       };
53978     }
53979   }
53980
53981 }
53982
53983
53984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53985   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53986   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53987
53988   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53989   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53990   {
53991     try {
53992       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53993     } catch (std::out_of_range& e) {
53994       {
53995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53996       };
53997     } catch (std::exception& e) {
53998       {
53999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54000       };
54001     } catch (Dali::DaliException e) {
54002       {
54003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54004       };
54005     } catch (...) {
54006       {
54007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54008       };
54009     }
54010   }
54011
54012 }
54013
54014
54015 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54016   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54017   Dali::Actor arg2 ;
54018   Dali::PanGesture *arg3 = 0 ;
54019   Dali::Actor *argp2 ;
54020
54021   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54022   argp2 = (Dali::Actor *)jarg2;
54023   if (!argp2) {
54024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54025     return ;
54026   }
54027   arg2 = *argp2;
54028   arg3 = (Dali::PanGesture *)jarg3;
54029   if (!arg3) {
54030     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
54031     return ;
54032   }
54033   {
54034     try {
54035       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
54036     } catch (std::out_of_range& e) {
54037       {
54038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54039       };
54040     } catch (std::exception& e) {
54041       {
54042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54043       };
54044     } catch (Dali::DaliException e) {
54045       {
54046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54047       };
54048     } catch (...) {
54049       {
54050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54051       };
54052     }
54053   }
54054
54055 }
54056
54057
54058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
54059   void * jresult ;
54060   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
54061
54062   {
54063     try {
54064       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
54065     } catch (std::out_of_range& e) {
54066       {
54067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54068       };
54069     } catch (std::exception& e) {
54070       {
54071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54072       };
54073     } catch (Dali::DaliException e) {
54074       {
54075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54076       };
54077     } catch (...) {
54078       {
54079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54080       };
54081     }
54082   }
54083
54084   jresult = (void *)result;
54085   return jresult;
54086 }
54087
54088
54089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
54090   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
54091
54092   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
54093   {
54094     try {
54095       delete arg1;
54096     } catch (std::out_of_range& e) {
54097       {
54098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54099       };
54100     } catch (std::exception& e) {
54101       {
54102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54103       };
54104     } catch (Dali::DaliException e) {
54105       {
54106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54107       };
54108     } catch (...) {
54109       {
54110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54111       };
54112     }
54113   }
54114
54115 }
54116
54117
54118 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
54119   unsigned int jresult ;
54120   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54121   bool result;
54122
54123   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54124   {
54125     try {
54126       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);
54127     } catch (std::out_of_range& e) {
54128       {
54129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54130       };
54131     } catch (std::exception& e) {
54132       {
54133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54134       };
54135     } catch (Dali::DaliException e) {
54136       {
54137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54138       };
54139     } catch (...) {
54140       {
54141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54142       };
54143     }
54144   }
54145
54146   jresult = result;
54147   return jresult;
54148 }
54149
54150
54151 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54152   unsigned long jresult ;
54153   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54154   std::size_t result;
54155
54156   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54157   {
54158     try {
54159       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);
54160     } catch (std::out_of_range& e) {
54161       {
54162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54163       };
54164     } catch (std::exception& e) {
54165       {
54166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54167       };
54168     } catch (Dali::DaliException e) {
54169       {
54170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54171       };
54172     } catch (...) {
54173       {
54174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54175       };
54176     }
54177   }
54178
54179   jresult = (unsigned long)result;
54180   return jresult;
54181 }
54182
54183
54184 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54185   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54186   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54187
54188   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54189   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54190   {
54191     try {
54192       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54193     } catch (std::out_of_range& e) {
54194       {
54195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54196       };
54197     } catch (std::exception& e) {
54198       {
54199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54200       };
54201     } catch (Dali::DaliException e) {
54202       {
54203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54204       };
54205     } catch (...) {
54206       {
54207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54208       };
54209     }
54210   }
54211
54212 }
54213
54214
54215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54216   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54217   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
54218
54219   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54220   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
54221   {
54222     try {
54223       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54224     } catch (std::out_of_range& e) {
54225       {
54226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54227       };
54228     } catch (std::exception& e) {
54229       {
54230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54231       };
54232     } catch (Dali::DaliException e) {
54233       {
54234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54235       };
54236     } catch (...) {
54237       {
54238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54239       };
54240     }
54241   }
54242
54243 }
54244
54245
54246 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54247   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54248   Dali::Actor arg2 ;
54249   Dali::PinchGesture *arg3 = 0 ;
54250   Dali::Actor *argp2 ;
54251
54252   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54253   argp2 = (Dali::Actor *)jarg2;
54254   if (!argp2) {
54255     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54256     return ;
54257   }
54258   arg2 = *argp2;
54259   arg3 = (Dali::PinchGesture *)jarg3;
54260   if (!arg3) {
54261     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
54262     return ;
54263   }
54264   {
54265     try {
54266       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
54267     } catch (std::out_of_range& e) {
54268       {
54269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54270       };
54271     } catch (std::exception& e) {
54272       {
54273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54274       };
54275     } catch (Dali::DaliException e) {
54276       {
54277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54278       };
54279     } catch (...) {
54280       {
54281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54282       };
54283     }
54284   }
54285
54286 }
54287
54288
54289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
54290   void * jresult ;
54291   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
54292
54293   {
54294     try {
54295       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
54296     } catch (std::out_of_range& e) {
54297       {
54298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54299       };
54300     } catch (std::exception& e) {
54301       {
54302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54303       };
54304     } catch (Dali::DaliException e) {
54305       {
54306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54307       };
54308     } catch (...) {
54309       {
54310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54311       };
54312     }
54313   }
54314
54315   jresult = (void *)result;
54316   return jresult;
54317 }
54318
54319
54320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
54321   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
54322
54323   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
54324   {
54325     try {
54326       delete arg1;
54327     } catch (std::out_of_range& e) {
54328       {
54329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54330       };
54331     } catch (std::exception& e) {
54332       {
54333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54334       };
54335     } catch (Dali::DaliException e) {
54336       {
54337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54338       };
54339     } catch (...) {
54340       {
54341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54342       };
54343     }
54344   }
54345
54346 }
54347
54348
54349 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
54350   unsigned int jresult ;
54351   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54352   bool result;
54353
54354   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54355   {
54356     try {
54357       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);
54358     } catch (std::out_of_range& e) {
54359       {
54360         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54361       };
54362     } catch (std::exception& e) {
54363       {
54364         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54365       };
54366     } catch (Dali::DaliException e) {
54367       {
54368         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54369       };
54370     } catch (...) {
54371       {
54372         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54373       };
54374     }
54375   }
54376
54377   jresult = result;
54378   return jresult;
54379 }
54380
54381
54382 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
54383   unsigned long jresult ;
54384   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54385   std::size_t result;
54386
54387   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54388   {
54389     try {
54390       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);
54391     } catch (std::out_of_range& e) {
54392       {
54393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54394       };
54395     } catch (std::exception& e) {
54396       {
54397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54398       };
54399     } catch (Dali::DaliException e) {
54400       {
54401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54402       };
54403     } catch (...) {
54404       {
54405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54406       };
54407     }
54408   }
54409
54410   jresult = (unsigned long)result;
54411   return jresult;
54412 }
54413
54414
54415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
54416   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54417   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54418
54419   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54420   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54421   {
54422     try {
54423       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
54424     } catch (std::out_of_range& e) {
54425       {
54426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54427       };
54428     } catch (std::exception& e) {
54429       {
54430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54431       };
54432     } catch (Dali::DaliException e) {
54433       {
54434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54435       };
54436     } catch (...) {
54437       {
54438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54439       };
54440     }
54441   }
54442
54443 }
54444
54445
54446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
54447   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54448   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
54449
54450   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54451   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
54452   {
54453     try {
54454       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
54455     } catch (std::out_of_range& e) {
54456       {
54457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54458       };
54459     } catch (std::exception& e) {
54460       {
54461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54462       };
54463     } catch (Dali::DaliException e) {
54464       {
54465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54466       };
54467     } catch (...) {
54468       {
54469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54470       };
54471     }
54472   }
54473
54474 }
54475
54476
54477 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
54478   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54479   Dali::Actor arg2 ;
54480   Dali::TapGesture *arg3 = 0 ;
54481   Dali::Actor *argp2 ;
54482
54483   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54484   argp2 = (Dali::Actor *)jarg2;
54485   if (!argp2) {
54486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54487     return ;
54488   }
54489   arg2 = *argp2;
54490   arg3 = (Dali::TapGesture *)jarg3;
54491   if (!arg3) {
54492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
54493     return ;
54494   }
54495   {
54496     try {
54497       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54498     } catch (std::out_of_range& e) {
54499       {
54500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54501       };
54502     } catch (std::exception& e) {
54503       {
54504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54505       };
54506     } catch (Dali::DaliException e) {
54507       {
54508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54509       };
54510     } catch (...) {
54511       {
54512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54513       };
54514     }
54515   }
54516
54517 }
54518
54519
54520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54521   void * jresult ;
54522   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54523
54524   {
54525     try {
54526       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54527     } catch (std::out_of_range& e) {
54528       {
54529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54530       };
54531     } catch (std::exception& e) {
54532       {
54533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54534       };
54535     } catch (Dali::DaliException e) {
54536       {
54537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54538       };
54539     } catch (...) {
54540       {
54541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54542       };
54543     }
54544   }
54545
54546   jresult = (void *)result;
54547   return jresult;
54548 }
54549
54550
54551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54552   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54553
54554   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54555   {
54556     try {
54557       delete arg1;
54558     } catch (std::out_of_range& e) {
54559       {
54560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54561       };
54562     } catch (std::exception& e) {
54563       {
54564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54565       };
54566     } catch (Dali::DaliException e) {
54567       {
54568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54569       };
54570     } catch (...) {
54571       {
54572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54573       };
54574     }
54575   }
54576
54577 }
54578
54579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54580   unsigned int jresult ;
54581   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54582   bool result = false;
54583
54584   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54585   {
54586     try {
54587       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);
54588     } catch (std::out_of_range& e) {
54589       {
54590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54591       };
54592     } catch (std::exception& e) {
54593       {
54594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54595       };
54596     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54597   }
54598   jresult = result;
54599   return jresult;
54600 }
54601
54602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54603   unsigned long jresult ;
54604   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54605   std::size_t result = 0;
54606
54607   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54608   {
54609     try {
54610       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);
54611     } catch (std::out_of_range& e) {
54612       {
54613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54614       };
54615     } catch (std::exception& e) {
54616       {
54617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54618       };
54619     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54620   }
54621   jresult = (unsigned long)result;
54622   return jresult;
54623 }
54624
54625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54626   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54627   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54628
54629   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54630   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54631   {
54632     try {
54633       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54634     } catch (std::out_of_range& e) {
54635       {
54636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54637       };
54638     } catch (std::exception& e) {
54639       {
54640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54641       };
54642     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54643   }
54644 }
54645
54646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54647   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54648   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54649
54650   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54651   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54652   {
54653     try {
54654       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54655     } catch (std::out_of_range& e) {
54656       {
54657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54658       };
54659     } catch (std::exception& e) {
54660       {
54661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54662       };
54663     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54664   }
54665 }
54666
54667 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54668   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54669   Dali::Actor arg2 ;
54670   //bool arg3 ;
54671   Dali::LayoutDirection::Type arg4 ;
54672   Dali::Actor *argp2 ;
54673
54674   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54675   argp2 = (Dali::Actor *)jarg2;
54676   if (!argp2) {
54677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54678     return ;
54679   }
54680   arg2 = *argp2;
54681   //arg3 = jarg3 ? true : false;
54682   arg4 = (Dali::LayoutDirection::Type)jarg4;
54683   {
54684     try {
54685       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54686     } catch (std::out_of_range& e) {
54687       {
54688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54689       };
54690     } catch (std::exception& e) {
54691       {
54692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54693       };
54694     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54695   }
54696 }
54697
54698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54699   void * jresult ;
54700   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54701
54702   {
54703     try {
54704       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54705     } catch (std::out_of_range& e) {
54706       {
54707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54708       };
54709     } catch (std::exception& e) {
54710       {
54711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54712       };
54713     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54714   }
54715   jresult = (void *)result;
54716   return jresult;
54717 }
54718
54719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54720   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54721
54722   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54723   {
54724     try {
54725       delete arg1;
54726     } catch (std::out_of_range& e) {
54727       {
54728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54729       };
54730     } catch (std::exception& e) {
54731       {
54732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54733       };
54734     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54735   }
54736 }
54737
54738 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54739   unsigned int jresult ;
54740   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54741   bool result;
54742
54743   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54744   {
54745     try {
54746       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);
54747     } catch (std::out_of_range& e) {
54748       {
54749         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54750       };
54751     } catch (std::exception& e) {
54752       {
54753         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54754       };
54755     } catch (Dali::DaliException e) {
54756       {
54757         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54758       };
54759     } catch (...) {
54760       {
54761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54762       };
54763     }
54764   }
54765
54766   jresult = result;
54767   return jresult;
54768 }
54769
54770
54771 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54772   unsigned long jresult ;
54773   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54774   std::size_t result;
54775
54776   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54777   {
54778     try {
54779       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);
54780     } catch (std::out_of_range& e) {
54781       {
54782         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54783       };
54784     } catch (std::exception& e) {
54785       {
54786         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54787       };
54788     } catch (Dali::DaliException e) {
54789       {
54790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54791       };
54792     } catch (...) {
54793       {
54794         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54795       };
54796     }
54797   }
54798
54799   jresult = (unsigned long)result;
54800   return jresult;
54801 }
54802
54803
54804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54805   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54806   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54807
54808   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54809   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54810   {
54811     try {
54812       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54813     } catch (std::out_of_range& e) {
54814       {
54815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54816       };
54817     } catch (std::exception& e) {
54818       {
54819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54820       };
54821     } catch (Dali::DaliException e) {
54822       {
54823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54824       };
54825     } catch (...) {
54826       {
54827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54828       };
54829     }
54830   }
54831
54832 }
54833
54834
54835 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54836   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54837   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54838
54839   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54840   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54841   {
54842     try {
54843       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54844     } catch (std::out_of_range& e) {
54845       {
54846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54847       };
54848     } catch (std::exception& e) {
54849       {
54850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54851       };
54852     } catch (Dali::DaliException e) {
54853       {
54854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54855       };
54856     } catch (...) {
54857       {
54858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54859       };
54860     }
54861   }
54862
54863 }
54864
54865
54866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54867   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54868   Dali::Actor arg2 ;
54869   bool arg3 ;
54870   Dali::DevelActor::VisibilityChange::Type arg4 ;
54871   Dali::Actor *argp2 ;
54872
54873   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54874   argp2 = (Dali::Actor *)jarg2;
54875   if (!argp2) {
54876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54877     return ;
54878   }
54879   arg2 = *argp2;
54880   arg3 = jarg3 ? true : false;
54881   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54882   {
54883     try {
54884       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54885     } catch (std::out_of_range& e) {
54886       {
54887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54888       };
54889     } catch (std::exception& e) {
54890       {
54891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54892       };
54893     } catch (Dali::DaliException e) {
54894       {
54895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54896       };
54897     } catch (...) {
54898       {
54899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54900       };
54901     }
54902   }
54903
54904 }
54905
54906
54907 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54908   void * jresult ;
54909   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54910
54911   {
54912     try {
54913       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54914     } catch (std::out_of_range& e) {
54915       {
54916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54917       };
54918     } catch (std::exception& e) {
54919       {
54920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54921       };
54922     } catch (Dali::DaliException e) {
54923       {
54924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54925       };
54926     } catch (...) {
54927       {
54928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54929       };
54930     }
54931   }
54932
54933   jresult = (void *)result;
54934   return jresult;
54935 }
54936
54937
54938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54939   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54940
54941   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54942   {
54943     try {
54944       delete arg1;
54945     } catch (std::out_of_range& e) {
54946       {
54947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54948       };
54949     } catch (std::exception& e) {
54950       {
54951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54952       };
54953     } catch (Dali::DaliException e) {
54954       {
54955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54956       };
54957     } catch (...) {
54958       {
54959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54960       };
54961     }
54962   }
54963
54964 }
54965
54966
54967 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54968   void * jresult ;
54969   Dali::Timer *result = 0 ;
54970
54971   {
54972     try {
54973       result = (Dali::Timer *)new Dali::Timer();
54974     } catch (std::out_of_range& e) {
54975       {
54976         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54977       };
54978     } catch (std::exception& e) {
54979       {
54980         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54981       };
54982     } catch (Dali::DaliException e) {
54983       {
54984         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54985       };
54986     } catch (...) {
54987       {
54988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54989       };
54990     }
54991   }
54992
54993   jresult = (void *)result;
54994   return jresult;
54995 }
54996
54997
54998 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54999   void * jresult ;
55000   unsigned int arg1 ;
55001   Dali::Timer result;
55002
55003   arg1 = (unsigned int)jarg1;
55004   {
55005     try {
55006       result = Dali::Timer::New(arg1);
55007     } catch (std::out_of_range& e) {
55008       {
55009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55010       };
55011     } catch (std::exception& e) {
55012       {
55013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55014       };
55015     } catch (Dali::DaliException e) {
55016       {
55017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55018       };
55019     } catch (...) {
55020       {
55021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55022       };
55023     }
55024   }
55025
55026   jresult = new Dali::Timer((const Dali::Timer &)result);
55027   return jresult;
55028 }
55029
55030
55031 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
55032   void * jresult ;
55033   Dali::Timer *arg1 = 0 ;
55034   Dali::Timer *result = 0 ;
55035
55036   arg1 = (Dali::Timer *)jarg1;
55037   if (!arg1) {
55038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55039     return 0;
55040   }
55041   {
55042     try {
55043       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
55044     } catch (std::out_of_range& e) {
55045       {
55046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55047       };
55048     } catch (std::exception& e) {
55049       {
55050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55051       };
55052     } catch (Dali::DaliException e) {
55053       {
55054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55055       };
55056     } catch (...) {
55057       {
55058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55059       };
55060     }
55061   }
55062
55063   jresult = (void *)result;
55064   return jresult;
55065 }
55066
55067
55068 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
55069   void * jresult ;
55070   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55071   Dali::Timer *arg2 = 0 ;
55072   Dali::Timer *result = 0 ;
55073
55074   arg1 = (Dali::Timer *)jarg1;
55075   arg2 = (Dali::Timer *)jarg2;
55076   if (!arg2) {
55077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
55078     return 0;
55079   }
55080   {
55081     try {
55082       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
55083     } catch (std::out_of_range& e) {
55084       {
55085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55086       };
55087     } catch (std::exception& e) {
55088       {
55089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55090       };
55091     } catch (Dali::DaliException e) {
55092       {
55093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55094       };
55095     } catch (...) {
55096       {
55097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55098       };
55099     }
55100   }
55101
55102   jresult = (void *)result;
55103   return jresult;
55104 }
55105
55106
55107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
55108   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55109
55110   arg1 = (Dali::Timer *)jarg1;
55111   {
55112     try {
55113       delete arg1;
55114     } catch (std::out_of_range& e) {
55115       {
55116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55117       };
55118     } catch (std::exception& e) {
55119       {
55120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55121       };
55122     } catch (Dali::DaliException e) {
55123       {
55124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55125       };
55126     } catch (...) {
55127       {
55128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55129       };
55130     }
55131   }
55132
55133 }
55134
55135
55136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
55137   void * jresult ;
55138   Dali::BaseHandle arg1 ;
55139   Dali::BaseHandle *argp1 ;
55140   Dali::Timer result;
55141
55142   argp1 = (Dali::BaseHandle *)jarg1;
55143   if (!argp1) {
55144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
55145     return 0;
55146   }
55147   arg1 = *argp1;
55148   {
55149     try {
55150       result = Dali::Timer::DownCast(arg1);
55151     } catch (std::out_of_range& e) {
55152       {
55153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55154       };
55155     } catch (std::exception& e) {
55156       {
55157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55158       };
55159     } catch (Dali::DaliException e) {
55160       {
55161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55162       };
55163     } catch (...) {
55164       {
55165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55166       };
55167     }
55168   }
55169
55170   jresult = new Dali::Timer((const Dali::Timer &)result);
55171   return jresult;
55172 }
55173
55174
55175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
55176   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55177
55178   arg1 = (Dali::Timer *)jarg1;
55179   {
55180     try {
55181       (arg1)->Start();
55182     } catch (std::out_of_range& e) {
55183       {
55184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55185       };
55186     } catch (std::exception& e) {
55187       {
55188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55189       };
55190     } catch (Dali::DaliException e) {
55191       {
55192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55193       };
55194     } catch (...) {
55195       {
55196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55197       };
55198     }
55199   }
55200
55201 }
55202
55203
55204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
55205   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55206
55207   arg1 = (Dali::Timer *)jarg1;
55208   {
55209     try {
55210       (arg1)->Stop();
55211     } catch (std::out_of_range& e) {
55212       {
55213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55214       };
55215     } catch (std::exception& e) {
55216       {
55217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55218       };
55219     } catch (Dali::DaliException e) {
55220       {
55221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55222       };
55223     } catch (...) {
55224       {
55225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55226       };
55227     }
55228   }
55229
55230 }
55231
55232
55233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
55234   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55235   unsigned int arg2 ;
55236
55237   arg1 = (Dali::Timer *)jarg1;
55238   arg2 = (unsigned int)jarg2;
55239   {
55240     try {
55241       (arg1)->SetInterval(arg2);
55242     } catch (std::out_of_range& e) {
55243       {
55244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55245       };
55246     } catch (std::exception& e) {
55247       {
55248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55249       };
55250     } catch (Dali::DaliException e) {
55251       {
55252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55253       };
55254     } catch (...) {
55255       {
55256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55257       };
55258     }
55259   }
55260
55261 }
55262
55263
55264 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
55265   unsigned int jresult ;
55266   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55267   unsigned int result;
55268
55269   arg1 = (Dali::Timer *)jarg1;
55270   {
55271     try {
55272       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
55273     } catch (std::out_of_range& e) {
55274       {
55275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55276       };
55277     } catch (std::exception& e) {
55278       {
55279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55280       };
55281     } catch (Dali::DaliException e) {
55282       {
55283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55284       };
55285     } catch (...) {
55286       {
55287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55288       };
55289     }
55290   }
55291
55292   jresult = result;
55293   return jresult;
55294 }
55295
55296
55297 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
55298   unsigned int jresult ;
55299   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55300   bool result;
55301
55302   arg1 = (Dali::Timer *)jarg1;
55303   {
55304     try {
55305       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
55306     } catch (std::out_of_range& e) {
55307       {
55308         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55309       };
55310     } catch (std::exception& e) {
55311       {
55312         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55313       };
55314     } catch (Dali::DaliException e) {
55315       {
55316         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55317       };
55318     } catch (...) {
55319       {
55320         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55321       };
55322     }
55323   }
55324
55325   jresult = result;
55326   return jresult;
55327 }
55328
55329
55330 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
55331   void * jresult ;
55332   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
55333   Dali::Timer::TimerSignalType *result = 0 ;
55334
55335   arg1 = (Dali::Timer *)jarg1;
55336   {
55337     try {
55338       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
55339     } catch (std::out_of_range& e) {
55340       {
55341         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55342       };
55343     } catch (std::exception& e) {
55344       {
55345         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55346       };
55347     } catch (Dali::DaliException e) {
55348       {
55349         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55350       };
55351     } catch (...) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55354       };
55355     }
55356   }
55357
55358   jresult = (void *)result;
55359   return jresult;
55360 }
55361
55362
55363 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
55364   unsigned int jresult ;
55365   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55366   bool result;
55367
55368   arg1 = (Dali::Signal< bool () > *)jarg1;
55369   {
55370     try {
55371       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
55372     } catch (std::out_of_range& e) {
55373       {
55374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55375       };
55376     } catch (std::exception& e) {
55377       {
55378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55379       };
55380     } catch (Dali::DaliException e) {
55381       {
55382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55383       };
55384     } catch (...) {
55385       {
55386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55387       };
55388     }
55389   }
55390
55391   jresult = result;
55392   return jresult;
55393 }
55394
55395
55396 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
55397   unsigned long jresult ;
55398   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55399   std::size_t result;
55400
55401   arg1 = (Dali::Signal< bool () > *)jarg1;
55402   {
55403     try {
55404       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
55405     } catch (std::out_of_range& e) {
55406       {
55407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55408       };
55409     } catch (std::exception& e) {
55410       {
55411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55412       };
55413     } catch (Dali::DaliException e) {
55414       {
55415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55416       };
55417     } catch (...) {
55418       {
55419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55420       };
55421     }
55422   }
55423
55424   jresult = (unsigned long)result;
55425   return jresult;
55426 }
55427
55428
55429 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
55430   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55431   bool (*arg2)() = (bool (*)()) 0 ;
55432
55433   arg1 = (Dali::Signal< bool () > *)jarg1;
55434   arg2 = (bool (*)())jarg2;
55435   {
55436     try {
55437       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
55438     } catch (std::out_of_range& e) {
55439       {
55440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55441       };
55442     } catch (std::exception& e) {
55443       {
55444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55445       };
55446     } catch (Dali::DaliException e) {
55447       {
55448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55449       };
55450     } catch (...) {
55451       {
55452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55453       };
55454     }
55455   }
55456
55457 }
55458
55459
55460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
55461   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55462   bool (*arg2)() = (bool (*)()) 0 ;
55463
55464   arg1 = (Dali::Signal< bool () > *)jarg1;
55465   arg2 = (bool (*)())jarg2;
55466   {
55467     try {
55468       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
55469     } catch (std::out_of_range& e) {
55470       {
55471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55472       };
55473     } catch (std::exception& e) {
55474       {
55475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55476       };
55477     } catch (Dali::DaliException e) {
55478       {
55479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55480       };
55481     } catch (...) {
55482       {
55483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55484       };
55485     }
55486   }
55487
55488 }
55489
55490
55491 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
55492   unsigned int jresult ;
55493   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55494   bool result;
55495
55496   arg1 = (Dali::Signal< bool () > *)jarg1;
55497   {
55498     try {
55499       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55500     } catch (std::out_of_range& e) {
55501       {
55502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55503       };
55504     } catch (std::exception& e) {
55505       {
55506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55507       };
55508     } catch (Dali::DaliException e) {
55509       {
55510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55511       };
55512     } catch (...) {
55513       {
55514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55515       };
55516     }
55517   }
55518
55519   jresult = result;
55520   return jresult;
55521 }
55522
55523
55524 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55525   void * jresult ;
55526   Dali::Signal< bool () > *result = 0 ;
55527
55528   {
55529     try {
55530       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55531     } catch (std::out_of_range& e) {
55532       {
55533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55534       };
55535     } catch (std::exception& e) {
55536       {
55537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55538       };
55539     } catch (Dali::DaliException e) {
55540       {
55541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55542       };
55543     } catch (...) {
55544       {
55545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55546       };
55547     }
55548   }
55549
55550   jresult = (void *)result;
55551   return jresult;
55552 }
55553
55554
55555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55556   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55557
55558   arg1 = (Dali::Signal< bool () > *)jarg1;
55559   {
55560     try {
55561       delete arg1;
55562     } catch (std::out_of_range& e) {
55563       {
55564         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55565       };
55566     } catch (std::exception& e) {
55567       {
55568         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55569       };
55570     } catch (Dali::DaliException e) {
55571       {
55572         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55573       };
55574     } catch (...) {
55575       {
55576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55577       };
55578     }
55579   }
55580
55581 }
55582
55583
55584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55585   int jresult ;
55586   int result;
55587
55588   {
55589     try {
55590       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55591     } catch (std::out_of_range& e) {
55592       {
55593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55594       };
55595     } catch (std::exception& e) {
55596       {
55597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55598       };
55599     } catch (Dali::DaliException e) {
55600       {
55601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55602       };
55603     } catch (...) {
55604       {
55605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55606       };
55607     }
55608   }
55609
55610   jresult = (int)result;
55611   return jresult;
55612 }
55613
55614
55615 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55616   int jresult ;
55617   int result;
55618
55619   {
55620     try {
55621       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55622     } catch (std::out_of_range& e) {
55623       {
55624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55625       };
55626     } catch (std::exception& e) {
55627       {
55628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55629       };
55630     } catch (Dali::DaliException e) {
55631       {
55632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55633       };
55634     } catch (...) {
55635       {
55636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55637       };
55638     }
55639   }
55640
55641   jresult = (int)result;
55642   return jresult;
55643 }
55644
55645
55646 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55647   int jresult ;
55648   int result;
55649
55650   {
55651     try {
55652       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55653     } catch (std::out_of_range& e) {
55654       {
55655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55656       };
55657     } catch (std::exception& e) {
55658       {
55659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55660       };
55661     } catch (Dali::DaliException e) {
55662       {
55663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55664       };
55665     } catch (...) {
55666       {
55667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55668       };
55669     }
55670   }
55671
55672   jresult = (int)result;
55673   return jresult;
55674 }
55675
55676
55677 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55678   int jresult ;
55679   int result;
55680
55681   {
55682     try {
55683       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55684     } catch (std::out_of_range& e) {
55685       {
55686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55687       };
55688     } catch (std::exception& e) {
55689       {
55690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55691       };
55692     } catch (Dali::DaliException e) {
55693       {
55694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55695       };
55696     } catch (...) {
55697       {
55698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55699       };
55700     }
55701   }
55702
55703   jresult = (int)result;
55704   return jresult;
55705 }
55706
55707
55708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55709   int jresult ;
55710   int result;
55711
55712   {
55713     try {
55714       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55715     } catch (std::out_of_range& e) {
55716       {
55717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55718       };
55719     } catch (std::exception& e) {
55720       {
55721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55722       };
55723     } catch (Dali::DaliException e) {
55724       {
55725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55726       };
55727     } catch (...) {
55728       {
55729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55730       };
55731     }
55732   }
55733
55734   jresult = (int)result;
55735   return jresult;
55736 }
55737
55738
55739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55740   int jresult ;
55741   int result;
55742
55743   {
55744     try {
55745       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55746     } catch (std::out_of_range& e) {
55747       {
55748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55749       };
55750     } catch (std::exception& e) {
55751       {
55752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55753       };
55754     } catch (Dali::DaliException e) {
55755       {
55756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55757       };
55758     } catch (...) {
55759       {
55760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55761       };
55762     }
55763   }
55764
55765   jresult = (int)result;
55766   return jresult;
55767 }
55768
55769
55770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55771   int jresult ;
55772   int result;
55773
55774   {
55775     try {
55776       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55777     } catch (std::out_of_range& e) {
55778       {
55779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55780       };
55781     } catch (std::exception& e) {
55782       {
55783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55784       };
55785     } catch (Dali::DaliException e) {
55786       {
55787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55788       };
55789     } catch (...) {
55790       {
55791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55792       };
55793     }
55794   }
55795
55796   jresult = (int)result;
55797   return jresult;
55798 }
55799
55800
55801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55802   int jresult ;
55803   int result;
55804
55805   {
55806     try {
55807       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55808     } catch (std::out_of_range& e) {
55809       {
55810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55811       };
55812     } catch (std::exception& e) {
55813       {
55814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55815       };
55816     } catch (Dali::DaliException e) {
55817       {
55818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55819       };
55820     } catch (...) {
55821       {
55822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55823       };
55824     }
55825   }
55826
55827   jresult = (int)result;
55828   return jresult;
55829 }
55830
55831
55832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55833   int jresult ;
55834   int result;
55835
55836   {
55837     try {
55838       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55839     } catch (std::out_of_range& e) {
55840       {
55841         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55842       };
55843     } catch (std::exception& e) {
55844       {
55845         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55846       };
55847     } catch (Dali::DaliException e) {
55848       {
55849         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55850       };
55851     } catch (...) {
55852       {
55853         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55854       };
55855     }
55856   }
55857
55858   jresult = (int)result;
55859   return jresult;
55860 }
55861
55862
55863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55864   int jresult ;
55865   int result;
55866
55867   {
55868     try {
55869       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55870     } catch (std::out_of_range& e) {
55871       {
55872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55873       };
55874     } catch (std::exception& e) {
55875       {
55876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55877       };
55878     } catch (Dali::DaliException e) {
55879       {
55880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55881       };
55882     } catch (...) {
55883       {
55884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55885       };
55886     }
55887   }
55888
55889   jresult = (int)result;
55890   return jresult;
55891 }
55892
55893
55894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55895   int jresult ;
55896   int result;
55897
55898   {
55899     try {
55900       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
55901     } catch (std::out_of_range& e) {
55902       {
55903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55904       };
55905     } catch (std::exception& e) {
55906       {
55907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55908       };
55909     } catch (Dali::DaliException e) {
55910       {
55911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55912       };
55913     } catch (...) {
55914       {
55915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55916       };
55917     }
55918   }
55919
55920   jresult = (int)result;
55921   return jresult;
55922 }
55923
55924
55925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55926   int jresult ;
55927   int result;
55928
55929   {
55930     try {
55931       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55932     } catch (std::out_of_range& e) {
55933       {
55934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55935       };
55936     } catch (std::exception& e) {
55937       {
55938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55939       };
55940     } catch (Dali::DaliException e) {
55941       {
55942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55943       };
55944     } catch (...) {
55945       {
55946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55947       };
55948     }
55949   }
55950
55951   jresult = (int)result;
55952   return jresult;
55953 }
55954
55955
55956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55957   int jresult ;
55958   int result;
55959
55960   {
55961     try {
55962       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55963     } catch (std::out_of_range& e) {
55964       {
55965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55966       };
55967     } catch (std::exception& e) {
55968       {
55969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55970       };
55971     } catch (Dali::DaliException e) {
55972       {
55973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55974       };
55975     } catch (...) {
55976       {
55977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55978       };
55979     }
55980   }
55981
55982   jresult = (int)result;
55983   return jresult;
55984 }
55985
55986
55987 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55988   int jresult ;
55989   int result;
55990
55991   {
55992     try {
55993       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55994     } catch (std::out_of_range& e) {
55995       {
55996         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55997       };
55998     } catch (std::exception& e) {
55999       {
56000         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56001       };
56002     } catch (Dali::DaliException e) {
56003       {
56004         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56005       };
56006     } catch (...) {
56007       {
56008         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56009       };
56010     }
56011   }
56012
56013   jresult = (int)result;
56014   return jresult;
56015 }
56016
56017
56018 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
56019   int jresult ;
56020   int result;
56021
56022   {
56023     try {
56024       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
56025     } catch (std::out_of_range& e) {
56026       {
56027         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56028       };
56029     } catch (std::exception& e) {
56030       {
56031         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56032       };
56033     } catch (Dali::DaliException e) {
56034       {
56035         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56036       };
56037     } catch (...) {
56038       {
56039         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56040       };
56041     }
56042   }
56043
56044   jresult = (int)result;
56045   return jresult;
56046 }
56047
56048
56049 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
56050   int jresult ;
56051   int result;
56052
56053   {
56054     try {
56055       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
56056     } catch (std::out_of_range& e) {
56057       {
56058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56059       };
56060     } catch (std::exception& e) {
56061       {
56062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56063       };
56064     } catch (Dali::DaliException e) {
56065       {
56066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56067       };
56068     } catch (...) {
56069       {
56070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56071       };
56072     }
56073   }
56074
56075   jresult = (int)result;
56076   return jresult;
56077 }
56078
56079
56080 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
56081   int jresult ;
56082   int result;
56083
56084   {
56085     try {
56086       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
56087     } catch (std::out_of_range& e) {
56088       {
56089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56090       };
56091     } catch (std::exception& e) {
56092       {
56093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56094       };
56095     } catch (Dali::DaliException e) {
56096       {
56097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56098       };
56099     } catch (...) {
56100       {
56101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56102       };
56103     }
56104   }
56105
56106   jresult = (int)result;
56107   return jresult;
56108 }
56109
56110
56111 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_UNITS_get() {
56112   int jresult ;
56113   int result;
56114
56115   {
56116     try {
56117       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
56118     } catch (std::out_of_range& e) {
56119       {
56120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56121       };
56122     } catch (std::exception& e) {
56123       {
56124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56125       };
56126     } catch (Dali::DaliException e) {
56127       {
56128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56129       };
56130     } catch (...) {
56131       {
56132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56133       };
56134     }
56135   }
56136
56137   jresult = (int)result;
56138   return jresult;
56139 }
56140
56141
56142 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_SPREAD_METHOD_get() {
56143   int jresult ;
56144   int result;
56145
56146   {
56147     try {
56148       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
56149     } catch (std::out_of_range& e) {
56150       {
56151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56152       };
56153     } catch (std::exception& e) {
56154       {
56155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56156       };
56157     } catch (Dali::DaliException e) {
56158       {
56159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56160       };
56161     } catch (...) {
56162       {
56163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56164       };
56165     }
56166   }
56167
56168   jresult = (int)result;
56169   return jresult;
56170 }
56171
56172
56173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_URL_get() {
56174   int jresult ;
56175   int result;
56176
56177   {
56178     try {
56179       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
56180     } catch (std::out_of_range& e) {
56181       {
56182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56183       };
56184     } catch (std::exception& e) {
56185       {
56186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56187       };
56188     } catch (Dali::DaliException e) {
56189       {
56190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56191       };
56192     } catch (...) {
56193       {
56194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56195       };
56196     }
56197   }
56198
56199   jresult = (int)result;
56200   return jresult;
56201 }
56202
56203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
56204   int jresult ;
56205   int result;
56206
56207   {
56208     try {
56209       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
56210     } catch (std::out_of_range& e) {
56211       {
56212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56213       };
56214     } catch (std::exception& e) {
56215       {
56216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56217       };
56218     } catch (Dali::DaliException e) {
56219       {
56220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56221       };
56222     } catch (...) {
56223       {
56224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56225       };
56226     }
56227   }
56228
56229   jresult = (int)result;
56230   return jresult;
56231 }
56232
56233
56234 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
56235   int jresult ;
56236   int result;
56237   {
56238     try
56239     {
56240       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
56241     } catch (std::out_of_range& e) {
56242       {
56243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56244       };
56245     } catch (std::exception& e) {
56246       {
56247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56248       };
56249     } catch (Dali::DaliException e) {
56250       {
56251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56252       };
56253     } catch (...) {
56254       {
56255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56256       };
56257     }
56258   }
56259
56260   jresult = (int)result;
56261   return jresult;
56262 }
56263
56264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
56265   int jresult ;
56266   int result;
56267   {
56268     try
56269     {
56270       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
56271     } catch (std::out_of_range& e) {
56272       {
56273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56274       };
56275     } catch (std::exception& e) {
56276       {
56277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56278       };
56279     } catch (Dali::DaliException e) {
56280       {
56281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56282       };
56283     } catch (...) {
56284       {
56285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56286       };
56287     }
56288   }
56289
56290   jresult = (int)result;
56291   return jresult;
56292 }
56293
56294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
56295   int jresult ;
56296   int result;
56297   {
56298     try
56299     {
56300       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
56301     } catch (std::out_of_range& e) {
56302       {
56303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56304       };
56305     } catch (std::exception& e) {
56306       {
56307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56308       };
56309     } catch (Dali::DaliException e) {
56310       {
56311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56312       };
56313     } catch (...) {
56314       {
56315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56316       };
56317     }
56318   }
56319
56320   jresult = (int)result;
56321   return jresult;
56322 }
56323
56324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
56325   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
56326 }
56327
56328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
56329   int jresult ;
56330   int result;
56331   {
56332     try
56333     {
56334       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
56335     } catch (std::out_of_range& e) {
56336       {
56337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56338       };
56339     } catch (std::exception& e) {
56340       {
56341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56342       };
56343     } catch (Dali::DaliException e) {
56344       {
56345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56346       };
56347     } catch (...) {
56348       {
56349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56350       };
56351     }
56352   }
56353
56354   jresult = (int)result;
56355   return jresult;
56356 }
56357
56358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
56359   int jresult ;
56360   int result;
56361   {
56362     try
56363     {
56364       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
56365     } catch (std::out_of_range& e) {
56366       {
56367         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56368       };
56369     } catch (std::exception& e) {
56370       {
56371         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56372       };
56373     } catch (Dali::DaliException e) {
56374       {
56375         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56376       };
56377     } catch (...) {
56378       {
56379         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56380       };
56381     }
56382   }
56383
56384   jresult = (int)result;
56385   return jresult;
56386 }
56387
56388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
56389   int jresult ;
56390   int result;
56391
56392   {
56393     try {
56394       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
56395     } catch (std::out_of_range& e) {
56396       {
56397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (std::exception& e) {
56400       {
56401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56402       };
56403     } catch (Dali::DaliException e) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56406       };
56407     } catch (...) {
56408       {
56409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56410       };
56411     }
56412   }
56413
56414   jresult = (int)result;
56415   return jresult;
56416 }
56417
56418
56419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
56420   int jresult ;
56421   int result;
56422
56423   {
56424     try {
56425       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
56426     } catch (std::out_of_range& e) {
56427       {
56428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56429       };
56430     } catch (std::exception& e) {
56431       {
56432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56433       };
56434     } catch (Dali::DaliException e) {
56435       {
56436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56437       };
56438     } catch (...) {
56439       {
56440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56441       };
56442     }
56443   }
56444
56445   jresult = (int)result;
56446   return jresult;
56447 }
56448
56449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
56450   int jresult ;
56451   int result;
56452   {
56453     try
56454     {
56455       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
56456     } catch (std::out_of_range& e) {
56457       {
56458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56459       };
56460     } catch (std::exception& e) {
56461       {
56462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56463       };
56464     } catch (...) {
56465       {
56466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56467       };
56468     }
56469   }
56470   jresult = (int)result;
56471   return jresult;
56472 }
56473
56474 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
56475   int jresult ;
56476   int result;
56477   {
56478     try
56479     {
56480       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
56481     } catch (std::out_of_range& e) {
56482       {
56483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56484       };
56485     } catch (std::exception& e) {
56486       {
56487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56488       };
56489     } catch (...) {
56490       {
56491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56492       };
56493     }
56494   }
56495   jresult = (int)result;
56496   return jresult;
56497 }
56498
56499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56500   int jresult ;
56501   int result;
56502   {
56503     try
56504     {
56505       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56506     } catch (std::out_of_range& e) {
56507       {
56508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56509       };
56510     } catch (std::exception& e) {
56511       {
56512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56513       };
56514     } catch (...) {
56515       {
56516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56517       };
56518     }
56519   }
56520   jresult = (int)result;
56521   return jresult;
56522 }
56523
56524
56525 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56526   int jresult ;
56527   int result;
56528   {
56529     try
56530     {
56531       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56532     } catch (std::out_of_range& e) {
56533       {
56534         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56535       };
56536     } catch (std::exception& e) {
56537       {
56538         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56539       };
56540     } catch (...) {
56541       {
56542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56543       };
56544     }
56545   }
56546   jresult = (int)result;
56547   return jresult;
56548 }
56549
56550 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56551   int jresult ;
56552   int result;
56553   {
56554     try
56555     {
56556       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56557     } catch (std::out_of_range& e) {
56558       {
56559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56560       };
56561     } catch (std::exception& e) {
56562       {
56563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56564       };
56565     } catch (...) {
56566       {
56567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56568       };
56569     }
56570   }
56571   jresult = (int)result;
56572   return jresult;
56573 }
56574
56575
56576
56577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56578   int jresult ;
56579   int result;
56580
56581   {
56582     try {
56583       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56584     } catch (std::out_of_range& e) {
56585       {
56586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56587       };
56588     } catch (std::exception& e) {
56589       {
56590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56591       };
56592     } catch (Dali::DaliException e) {
56593       {
56594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56595       };
56596     } catch (...) {
56597       {
56598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56599       };
56600     }
56601   }
56602
56603   jresult = (int)result;
56604   return jresult;
56605 }
56606
56607
56608 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56609   int jresult ;
56610   int result;
56611
56612   {
56613     try {
56614       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56615     } catch (std::out_of_range& e) {
56616       {
56617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56618       };
56619     } catch (std::exception& e) {
56620       {
56621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56622       };
56623     } catch (Dali::DaliException e) {
56624       {
56625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56626       };
56627     } catch (...) {
56628       {
56629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56630       };
56631     }
56632   }
56633
56634   jresult = (int)result;
56635   return jresult;
56636 }
56637
56638
56639 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56640   int jresult ;
56641   int result;
56642
56643   {
56644     try {
56645       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56646     } catch (std::out_of_range& e) {
56647       {
56648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56649       };
56650     } catch (std::exception& e) {
56651       {
56652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56653       };
56654     } catch (Dali::DaliException e) {
56655       {
56656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56657       };
56658     } catch (...) {
56659       {
56660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56661       };
56662     }
56663   }
56664
56665   jresult = (int)result;
56666   return jresult;
56667 }
56668
56669
56670 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56671   int jresult ;
56672   int result;
56673
56674   {
56675     try {
56676       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56677     } catch (std::out_of_range& e) {
56678       {
56679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56680       };
56681     } catch (std::exception& e) {
56682       {
56683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56684       };
56685     } catch (Dali::DaliException e) {
56686       {
56687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56688       };
56689     } catch (...) {
56690       {
56691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56692       };
56693     }
56694   }
56695
56696   jresult = (int)result;
56697   return jresult;
56698 }
56699
56700
56701 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56702   int jresult ;
56703   int result;
56704
56705   {
56706     try {
56707       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56708     } catch (std::out_of_range& e) {
56709       {
56710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56711       };
56712     } catch (std::exception& e) {
56713       {
56714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56715       };
56716     } catch (Dali::DaliException e) {
56717       {
56718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56719       };
56720     } catch (...) {
56721       {
56722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56723       };
56724     }
56725   }
56726
56727   jresult = (int)result;
56728   return jresult;
56729 }
56730
56731
56732 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56733   int jresult ;
56734   int result;
56735
56736   {
56737     try {
56738       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56739     } catch (std::out_of_range& e) {
56740       {
56741         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56742       };
56743     } catch (std::exception& e) {
56744       {
56745         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56746       };
56747     } catch (Dali::DaliException e) {
56748       {
56749         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56750       };
56751     } catch (...) {
56752       {
56753         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56754       };
56755     }
56756   }
56757
56758   jresult = (int)result;
56759   return jresult;
56760 }
56761
56762
56763 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56764   int jresult ;
56765   int result;
56766
56767   {
56768     try {
56769       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56770     } catch (std::out_of_range& e) {
56771       {
56772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56773       };
56774     } catch (std::exception& e) {
56775       {
56776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56777       };
56778     } catch (Dali::DaliException e) {
56779       {
56780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56781       };
56782     } catch (...) {
56783       {
56784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56785       };
56786     }
56787   }
56788
56789   jresult = (int)result;
56790   return jresult;
56791 }
56792
56793 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56794   int jresult ;
56795   int result;
56796
56797   {
56798     try {
56799       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
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 (...) {
56809       {
56810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56811       };
56812     }
56813   }
56814   jresult = (int)result;
56815   return jresult;
56816 }
56817
56818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56819   int jresult ;
56820   int result;
56821
56822   {
56823     try {
56824       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56825     } catch (std::out_of_range& e) {
56826       {
56827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56828       };
56829     } catch (std::exception& e) {
56830       {
56831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56832       };
56833     } catch (Dali::DaliException e) {
56834       {
56835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56836       };
56837     } catch (...) {
56838       {
56839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56840       };
56841     }
56842   }
56843
56844   jresult = (int)result;
56845   return jresult;
56846 }
56847
56848
56849 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56850   int jresult ;
56851   int result;
56852
56853   {
56854     try {
56855       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56856     } catch (std::out_of_range& e) {
56857       {
56858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56859       };
56860     } catch (std::exception& e) {
56861       {
56862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56863       };
56864     } catch (Dali::DaliException e) {
56865       {
56866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56867       };
56868     } catch (...) {
56869       {
56870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56871       };
56872     }
56873   }
56874
56875   jresult = (int)result;
56876   return jresult;
56877 }
56878
56879
56880 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56881   int jresult ;
56882   int result;
56883
56884   {
56885     try {
56886       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56887     } catch (std::out_of_range& e) {
56888       {
56889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56890       };
56891     } catch (std::exception& e) {
56892       {
56893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56894       };
56895     } catch (Dali::DaliException e) {
56896       {
56897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56898       };
56899     } catch (...) {
56900       {
56901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56902       };
56903     }
56904   }
56905
56906   jresult = (int)result;
56907   return jresult;
56908 }
56909
56910
56911 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56912   int jresult ;
56913   int result;
56914
56915   {
56916     try {
56917       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56918     } catch (std::out_of_range& e) {
56919       {
56920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56921       };
56922     } catch (std::exception& e) {
56923       {
56924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56925       };
56926     } catch (Dali::DaliException e) {
56927       {
56928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56929       };
56930     } catch (...) {
56931       {
56932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56933       };
56934     }
56935   }
56936
56937   jresult = (int)result;
56938   return jresult;
56939 }
56940
56941
56942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56943   int jresult ;
56944   int result;
56945
56946   {
56947     try {
56948       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56949     } catch (std::out_of_range& e) {
56950       {
56951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56952       };
56953     } catch (std::exception& e) {
56954       {
56955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56956       };
56957     } catch (Dali::DaliException e) {
56958       {
56959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56960       };
56961     } catch (...) {
56962       {
56963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56964       };
56965     }
56966   }
56967
56968   jresult = (int)result;
56969   return jresult;
56970 }
56971
56972
56973 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56974   int jresult ;
56975   int result;
56976
56977   {
56978     try {
56979       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56980     } catch (std::out_of_range& e) {
56981       {
56982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56983       };
56984     } catch (std::exception& e) {
56985       {
56986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56987       };
56988     } catch (Dali::DaliException e) {
56989       {
56990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56991       };
56992     } catch (...) {
56993       {
56994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56995       };
56996     }
56997   }
56998
56999   jresult = (int)result;
57000   return jresult;
57001 }
57002
57003
57004 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
57005   int jresult ;
57006   int result;
57007
57008   {
57009     try {
57010       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
57011     } catch (std::out_of_range& e) {
57012       {
57013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57014       };
57015     } catch (std::exception& e) {
57016       {
57017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57018       };
57019     } catch (Dali::DaliException e) {
57020       {
57021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57022       };
57023     } catch (...) {
57024       {
57025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57026       };
57027     }
57028   }
57029
57030   jresult = (int)result;
57031   return jresult;
57032 }
57033
57034
57035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
57036   int jresult ;
57037   int result;
57038
57039   {
57040     try {
57041       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
57042     } catch (std::out_of_range& e) {
57043       {
57044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57045       };
57046     } catch (std::exception& e) {
57047       {
57048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57049       };
57050     } catch (Dali::DaliException e) {
57051       {
57052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57053       };
57054     } catch (...) {
57055       {
57056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57057       };
57058     }
57059   }
57060
57061   jresult = (int)result;
57062   return jresult;
57063 }
57064
57065
57066 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
57067   int jresult ;
57068   int result;
57069
57070   {
57071     try {
57072       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
57073     } catch (std::out_of_range& e) {
57074       {
57075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57076       };
57077     } catch (std::exception& e) {
57078       {
57079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57080       };
57081     } catch (Dali::DaliException e) {
57082       {
57083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57084       };
57085     } catch (...) {
57086       {
57087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57088       };
57089     }
57090   }
57091
57092   jresult = (int)result;
57093   return jresult;
57094 }
57095
57096
57097 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
57098   int jresult ;
57099   int result;
57100
57101   {
57102     try {
57103       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
57104     } catch (std::out_of_range& e) {
57105       {
57106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57107       };
57108     } catch (std::exception& e) {
57109       {
57110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57111       };
57112     } catch (Dali::DaliException e) {
57113       {
57114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57115       };
57116     } catch (...) {
57117       {
57118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57119       };
57120     }
57121   }
57122
57123   jresult = (int)result;
57124   return jresult;
57125 }
57126
57127
57128 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
57129   int jresult ;
57130   int result;
57131
57132   {
57133     try {
57134       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
57135     } catch (std::out_of_range& e) {
57136       {
57137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57138       };
57139     } catch (std::exception& e) {
57140       {
57141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57142       };
57143     } catch (Dali::DaliException e) {
57144       {
57145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57146       };
57147     } catch (...) {
57148       {
57149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57150       };
57151     }
57152   }
57153
57154   jresult = (int)result;
57155   return jresult;
57156 }
57157
57158
57159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
57160   int jresult ;
57161   int result;
57162
57163   {
57164     try {
57165       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
57166     } catch (std::out_of_range& e) {
57167       {
57168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57169       };
57170     } catch (std::exception& e) {
57171       {
57172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57173       };
57174     } catch (Dali::DaliException e) {
57175       {
57176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57177       };
57178     } catch (...) {
57179       {
57180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57181       };
57182     }
57183   }
57184
57185   jresult = (int)result;
57186   return jresult;
57187 }
57188
57189
57190 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
57191   int jresult ;
57192   int result;
57193
57194   {
57195     try {
57196       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
57197     } catch (std::out_of_range& e) {
57198       {
57199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57200       };
57201     } catch (std::exception& e) {
57202       {
57203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57204       };
57205     } catch (Dali::DaliException e) {
57206       {
57207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57208       };
57209     } catch (...) {
57210       {
57211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57212       };
57213     }
57214   }
57215
57216   jresult = (int)result;
57217   return jresult;
57218 }
57219
57220
57221 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
57222   int jresult ;
57223   int result;
57224
57225   {
57226     try {
57227       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
57228     } catch (std::out_of_range& e) {
57229       {
57230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57231       };
57232     } catch (std::exception& e) {
57233       {
57234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57235       };
57236     } catch (Dali::DaliException e) {
57237       {
57238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57239       };
57240     } catch (...) {
57241       {
57242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57243       };
57244     }
57245   }
57246
57247   jresult = (int)result;
57248   return jresult;
57249 }
57250
57251
57252 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
57253   int jresult ;
57254   int result;
57255
57256   {
57257     try {
57258       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
57259     } catch (std::out_of_range& e) {
57260       {
57261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57262       };
57263     } catch (std::exception& e) {
57264       {
57265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57266       };
57267     } catch (Dali::DaliException e) {
57268       {
57269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57270       };
57271     } catch (...) {
57272       {
57273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57274       };
57275     }
57276   }
57277
57278   jresult = (int)result;
57279   return jresult;
57280 }
57281
57282
57283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
57284   int jresult ;
57285   int result;
57286
57287   {
57288     try {
57289       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
57290     } catch (std::out_of_range& e) {
57291       {
57292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57293       };
57294     } catch (std::exception& e) {
57295       {
57296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57297       };
57298     } catch (Dali::DaliException e) {
57299       {
57300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57301       };
57302     } catch (...) {
57303       {
57304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57305       };
57306     }
57307   }
57308
57309   jresult = (int)result;
57310   return jresult;
57311 }
57312
57313
57314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
57315   int jresult ;
57316   int result;
57317
57318   {
57319     try {
57320       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
57321     } catch (std::out_of_range& e) {
57322       {
57323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57324       };
57325     } catch (std::exception& e) {
57326       {
57327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57328       };
57329     } catch (Dali::DaliException e) {
57330       {
57331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57332       };
57333     } catch (...) {
57334       {
57335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57336       };
57337     }
57338   }
57339
57340   jresult = (int)result;
57341   return jresult;
57342 }
57343
57344
57345 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
57346   int jresult ;
57347   int result;
57348
57349   {
57350     try {
57351       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
57352     } catch (std::out_of_range& e) {
57353       {
57354         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57355       };
57356     } catch (std::exception& e) {
57357       {
57358         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57359       };
57360     } catch (Dali::DaliException e) {
57361       {
57362         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57363       };
57364     } catch (...) {
57365       {
57366         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57367       };
57368     }
57369   }
57370
57371   jresult = (int)result;
57372   return jresult;
57373 }
57374
57375
57376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
57377   int jresult ;
57378   int result;
57379
57380   {
57381     try {
57382       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
57383     } catch (std::out_of_range& e) {
57384       {
57385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57386       };
57387     } catch (std::exception& e) {
57388       {
57389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57390       };
57391     } catch (Dali::DaliException e) {
57392       {
57393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57394       };
57395     } catch (...) {
57396       {
57397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57398       };
57399     }
57400   }
57401
57402   jresult = (int)result;
57403   return jresult;
57404 }
57405
57406
57407 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_get() {
57408   int jresult ;
57409   int result;
57410
57411   {
57412     try {
57413       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
57414     } catch (std::out_of_range& e) {
57415       {
57416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57417       };
57418     } catch (std::exception& e) {
57419       {
57420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57421       };
57422     } catch (Dali::DaliException e) {
57423       {
57424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57425       };
57426     } catch (...) {
57427       {
57428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57429       };
57430     }
57431   }
57432
57433   jresult = (int)result;
57434   return jresult;
57435 }
57436
57437
57438 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_FAMILY_get() {
57439   int jresult ;
57440   int result;
57441
57442   {
57443     try {
57444       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
57445     } catch (std::out_of_range& e) {
57446       {
57447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57448       };
57449     } catch (std::exception& e) {
57450       {
57451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57452       };
57453     } catch (Dali::DaliException e) {
57454       {
57455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57456       };
57457     } catch (...) {
57458       {
57459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57460       };
57461     }
57462   }
57463
57464   jresult = (int)result;
57465   return jresult;
57466 }
57467
57468
57469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_FONT_STYLE_get() {
57470   int jresult ;
57471   int result;
57472
57473   {
57474     try {
57475       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
57476     } catch (std::out_of_range& e) {
57477       {
57478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57479       };
57480     } catch (std::exception& e) {
57481       {
57482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57483       };
57484     } catch (Dali::DaliException e) {
57485       {
57486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57487       };
57488     } catch (...) {
57489       {
57490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57491       };
57492     }
57493   }
57494
57495   jresult = (int)result;
57496   return jresult;
57497 }
57498
57499
57500 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_POINT_SIZE_get() {
57501   int jresult ;
57502   int result;
57503
57504   {
57505     try {
57506       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
57507     } catch (std::out_of_range& e) {
57508       {
57509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57510       };
57511     } catch (std::exception& e) {
57512       {
57513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57514       };
57515     } catch (Dali::DaliException e) {
57516       {
57517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57518       };
57519     } catch (...) {
57520       {
57521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57522       };
57523     }
57524   }
57525
57526   jresult = (int)result;
57527   return jresult;
57528 }
57529
57530
57531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_MULTI_LINE_get() {
57532   int jresult ;
57533   int result;
57534
57535   {
57536     try {
57537       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
57538     } catch (std::out_of_range& e) {
57539       {
57540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57541       };
57542     } catch (std::exception& e) {
57543       {
57544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57545       };
57546     } catch (Dali::DaliException e) {
57547       {
57548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57549       };
57550     } catch (...) {
57551       {
57552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57553       };
57554     }
57555   }
57556
57557   jresult = (int)result;
57558   return jresult;
57559 }
57560
57561
57562 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57563   int jresult ;
57564   int result;
57565
57566   {
57567     try {
57568       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
57569     } catch (std::out_of_range& e) {
57570       {
57571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57572       };
57573     } catch (std::exception& e) {
57574       {
57575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57576       };
57577     } catch (Dali::DaliException e) {
57578       {
57579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57580       };
57581     } catch (...) {
57582       {
57583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57584       };
57585     }
57586   }
57587
57588   jresult = (int)result;
57589   return jresult;
57590 }
57591
57592
57593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57594   int jresult ;
57595   int result;
57596
57597   {
57598     try {
57599       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
57600     } catch (std::out_of_range& e) {
57601       {
57602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57603       };
57604     } catch (std::exception& e) {
57605       {
57606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57607       };
57608     } catch (Dali::DaliException e) {
57609       {
57610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57611       };
57612     } catch (...) {
57613       {
57614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57615       };
57616     }
57617   }
57618
57619   jresult = (int)result;
57620   return jresult;
57621 }
57622
57623
57624 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_TEXT_COLOR_get() {
57625   int jresult ;
57626   int result;
57627
57628   {
57629     try {
57630       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57631     } catch (std::out_of_range& e) {
57632       {
57633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57634       };
57635     } catch (std::exception& e) {
57636       {
57637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57638       };
57639     } catch (Dali::DaliException e) {
57640       {
57641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57642       };
57643     } catch (...) {
57644       {
57645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57646       };
57647     }
57648   }
57649
57650   jresult = (int)result;
57651   return jresult;
57652 }
57653
57654
57655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TEXT_VISUAL_ENABLE_MARKUP_get() {
57656   int jresult ;
57657   int result;
57658
57659   {
57660     try {
57661       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
57662     } catch (std::out_of_range& e) {
57663       {
57664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57665       };
57666     } catch (std::exception& e) {
57667       {
57668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57669       };
57670     } catch (Dali::DaliException e) {
57671       {
57672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57673       };
57674     } catch (...) {
57675       {
57676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57677       };
57678     }
57679   }
57680
57681   jresult = (int)result;
57682   return jresult;
57683 }
57684
57685
57686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57687   void * jresult ;
57688   Dali::Toolkit::Builder *result = 0 ;
57689
57690   {
57691     try {
57692       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
57693     } catch (std::out_of_range& e) {
57694       {
57695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57696       };
57697     } catch (std::exception& e) {
57698       {
57699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57700       };
57701     } catch (Dali::DaliException e) {
57702       {
57703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57704       };
57705     } catch (...) {
57706       {
57707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57708       };
57709     }
57710   }
57711
57712   jresult = (void *)result;
57713   return jresult;
57714 }
57715
57716
57717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57718   void * jresult ;
57719   Dali::Toolkit::Builder result;
57720
57721   {
57722     try {
57723       result = Dali::Toolkit::Builder::New();
57724     } catch (std::out_of_range& e) {
57725       {
57726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57727       };
57728     } catch (std::exception& e) {
57729       {
57730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57731       };
57732     } catch (Dali::DaliException e) {
57733       {
57734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57735       };
57736     } catch (...) {
57737       {
57738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57739       };
57740     }
57741   }
57742
57743   jresult = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57744   return jresult;
57745 }
57746
57747
57748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57749   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57750
57751   arg1 = (Dali::Toolkit::Builder *)jarg1;
57752   {
57753     try {
57754       delete arg1;
57755     } catch (std::out_of_range& e) {
57756       {
57757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57758       };
57759     } catch (std::exception& e) {
57760       {
57761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57762       };
57763     } catch (Dali::DaliException e) {
57764       {
57765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57766       };
57767     } catch (...) {
57768       {
57769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57770       };
57771     }
57772   }
57773
57774 }
57775
57776
57777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57778   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57779   std::string *arg2 = 0 ;
57780   Dali::Toolkit::Builder::UIFormat arg3 ;
57781
57782   arg1 = (Dali::Toolkit::Builder *)jarg1;
57783   if (!jarg2) {
57784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57785     return ;
57786   }
57787   std::string arg2_str(jarg2);
57788   arg2 = &arg2_str;
57789   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57790   {
57791     try {
57792       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57793     } catch (std::out_of_range& e) {
57794       {
57795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57796       };
57797     } catch (std::exception& e) {
57798       {
57799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57800       };
57801     } catch (Dali::DaliException e) {
57802       {
57803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57804       };
57805     } catch (...) {
57806       {
57807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57808       };
57809     }
57810   }
57811
57812
57813   //argout typemap for const std::string&
57814
57815 }
57816
57817
57818 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57819   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57820   std::string *arg2 = 0 ;
57821
57822   arg1 = (Dali::Toolkit::Builder *)jarg1;
57823   if (!jarg2) {
57824     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57825     return ;
57826   }
57827   std::string arg2_str(jarg2);
57828   arg2 = &arg2_str;
57829   {
57830     try {
57831       (arg1)->LoadFromString((std::string const &)*arg2);
57832     } catch (std::out_of_range& e) {
57833       {
57834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57835       };
57836     } catch (std::exception& e) {
57837       {
57838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57839       };
57840     } catch (Dali::DaliException e) {
57841       {
57842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57843       };
57844     } catch (...) {
57845       {
57846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57847       };
57848     }
57849   }
57850
57851
57852   //argout typemap for const std::string&
57853
57854 }
57855
57856
57857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57858   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57859   Dali::Property::Map *arg2 = 0 ;
57860
57861   arg1 = (Dali::Toolkit::Builder *)jarg1;
57862   arg2 = (Dali::Property::Map *)jarg2;
57863   if (!arg2) {
57864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57865     return ;
57866   }
57867   {
57868     try {
57869       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57870     } catch (std::out_of_range& e) {
57871       {
57872         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57873       };
57874     } catch (std::exception& e) {
57875       {
57876         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57877       };
57878     } catch (Dali::DaliException e) {
57879       {
57880         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57881       };
57882     } catch (...) {
57883       {
57884         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57885       };
57886     }
57887   }
57888
57889 }
57890
57891
57892 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57893   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57894   std::string *arg2 = 0 ;
57895   Dali::Property::Value *arg3 = 0 ;
57896
57897   arg1 = (Dali::Toolkit::Builder *)jarg1;
57898   if (!jarg2) {
57899     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57900     return ;
57901   }
57902   std::string arg2_str(jarg2);
57903   arg2 = &arg2_str;
57904   arg3 = (Dali::Property::Value *)jarg3;
57905   if (!arg3) {
57906     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57907     return ;
57908   }
57909   {
57910     try {
57911       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57912     } catch (std::out_of_range& e) {
57913       {
57914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57915       };
57916     } catch (std::exception& e) {
57917       {
57918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57919       };
57920     } catch (Dali::DaliException e) {
57921       {
57922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57923       };
57924     } catch (...) {
57925       {
57926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57927       };
57928     }
57929   }
57930
57931
57932   //argout typemap for const std::string&
57933
57934 }
57935
57936
57937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57938   void * jresult ;
57939   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57940   Dali::Property::Map *result = 0 ;
57941
57942   arg1 = (Dali::Toolkit::Builder *)jarg1;
57943   {
57944     try {
57945       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57946     } catch (std::out_of_range& e) {
57947       {
57948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57949       };
57950     } catch (std::exception& e) {
57951       {
57952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57953       };
57954     } catch (Dali::DaliException e) {
57955       {
57956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57957       };
57958     } catch (...) {
57959       {
57960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57961       };
57962     }
57963   }
57964
57965   jresult = (void *)result;
57966   return jresult;
57967 }
57968
57969
57970 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57971   void * jresult ;
57972   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57973   std::string *arg2 = 0 ;
57974   Dali::Property::Value *result = 0 ;
57975
57976   arg1 = (Dali::Toolkit::Builder *)jarg1;
57977   if (!jarg2) {
57978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57979     return 0;
57980   }
57981   std::string arg2_str(jarg2);
57982   arg2 = &arg2_str;
57983   {
57984     try {
57985       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57986     } catch (std::out_of_range& e) {
57987       {
57988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57989       };
57990     } catch (std::exception& e) {
57991       {
57992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57993       };
57994     } catch (Dali::DaliException e) {
57995       {
57996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57997       };
57998     } catch (...) {
57999       {
58000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58001       };
58002     }
58003   }
58004
58005   jresult = (void *)result;
58006
58007   //argout typemap for const std::string&
58008
58009   return jresult;
58010 }
58011
58012
58013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
58014   void * jresult ;
58015   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58016   std::string *arg2 = 0 ;
58017   Dali::Animation result;
58018
58019   arg1 = (Dali::Toolkit::Builder *)jarg1;
58020   if (!jarg2) {
58021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58022     return 0;
58023   }
58024   std::string arg2_str(jarg2);
58025   arg2 = &arg2_str;
58026   {
58027     try {
58028       result = (arg1)->CreateAnimation((std::string const &)*arg2);
58029     } catch (std::out_of_range& e) {
58030       {
58031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58032       };
58033     } catch (std::exception& e) {
58034       {
58035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58036       };
58037     } catch (Dali::DaliException e) {
58038       {
58039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58040       };
58041     } catch (...) {
58042       {
58043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58044       };
58045     }
58046   }
58047
58048   jresult = new Dali::Animation((const Dali::Animation &)result);
58049
58050   //argout typemap for const std::string&
58051
58052   return jresult;
58053 }
58054
58055
58056 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58057   void * jresult ;
58058   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58059   std::string *arg2 = 0 ;
58060   Dali::Property::Map *arg3 = 0 ;
58061   Dali::Animation result;
58062
58063   arg1 = (Dali::Toolkit::Builder *)jarg1;
58064   if (!jarg2) {
58065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58066     return 0;
58067   }
58068   std::string arg2_str(jarg2);
58069   arg2 = &arg2_str;
58070   arg3 = (Dali::Property::Map *)jarg3;
58071   if (!arg3) {
58072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58073     return 0;
58074   }
58075   {
58076     try {
58077       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58078     } catch (std::out_of_range& e) {
58079       {
58080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58081       };
58082     } catch (std::exception& e) {
58083       {
58084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58085       };
58086     } catch (Dali::DaliException e) {
58087       {
58088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58089       };
58090     } catch (...) {
58091       {
58092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58093       };
58094     }
58095   }
58096
58097   jresult = new Dali::Animation((const Dali::Animation &)result);
58098
58099   //argout typemap for const std::string&
58100
58101   return jresult;
58102 }
58103
58104
58105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
58106   void * jresult ;
58107   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58108   std::string *arg2 = 0 ;
58109   Dali::Actor arg3 ;
58110   Dali::Actor *argp3 ;
58111   Dali::Animation result;
58112
58113   arg1 = (Dali::Toolkit::Builder *)jarg1;
58114   if (!jarg2) {
58115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58116     return 0;
58117   }
58118   std::string arg2_str(jarg2);
58119   arg2 = &arg2_str;
58120   argp3 = (Dali::Actor *)jarg3;
58121   if (!argp3) {
58122     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58123     return 0;
58124   }
58125   arg3 = *argp3;
58126   {
58127     try {
58128       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
58129     } catch (std::out_of_range& e) {
58130       {
58131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58132       };
58133     } catch (std::exception& e) {
58134       {
58135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58136       };
58137     } catch (Dali::DaliException e) {
58138       {
58139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58140       };
58141     } catch (...) {
58142       {
58143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58144       };
58145     }
58146   }
58147
58148   jresult = new Dali::Animation((const Dali::Animation &)result);
58149
58150   //argout typemap for const std::string&
58151
58152   return jresult;
58153 }
58154
58155
58156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
58157   void * jresult ;
58158   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58159   std::string *arg2 = 0 ;
58160   Dali::Property::Map *arg3 = 0 ;
58161   Dali::Actor arg4 ;
58162   Dali::Actor *argp4 ;
58163   Dali::Animation result;
58164
58165   arg1 = (Dali::Toolkit::Builder *)jarg1;
58166   if (!jarg2) {
58167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58168     return 0;
58169   }
58170   std::string arg2_str(jarg2);
58171   arg2 = &arg2_str;
58172   arg3 = (Dali::Property::Map *)jarg3;
58173   if (!arg3) {
58174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58175     return 0;
58176   }
58177   argp4 = (Dali::Actor *)jarg4;
58178   if (!argp4) {
58179     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58180     return 0;
58181   }
58182   arg4 = *argp4;
58183   {
58184     try {
58185       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
58186     } catch (std::out_of_range& e) {
58187       {
58188         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58189       };
58190     } catch (std::exception& e) {
58191       {
58192         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58193       };
58194     } catch (Dali::DaliException e) {
58195       {
58196         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58197       };
58198     } catch (...) {
58199       {
58200         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58201       };
58202     }
58203   }
58204
58205   jresult = new Dali::Animation((const Dali::Animation &)result);
58206
58207   //argout typemap for const std::string&
58208
58209   return jresult;
58210 }
58211
58212
58213 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
58214   void * jresult ;
58215   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58216   std::string *arg2 = 0 ;
58217   Dali::BaseHandle result;
58218
58219   arg1 = (Dali::Toolkit::Builder *)jarg1;
58220   if (!jarg2) {
58221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58222     return 0;
58223   }
58224   std::string arg2_str(jarg2);
58225   arg2 = &arg2_str;
58226   {
58227     try {
58228       result = (arg1)->Create((std::string const &)*arg2);
58229     } catch (std::out_of_range& e) {
58230       {
58231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58232       };
58233     } catch (std::exception& e) {
58234       {
58235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58236       };
58237     } catch (Dali::DaliException e) {
58238       {
58239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58240       };
58241     } catch (...) {
58242       {
58243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58244       };
58245     }
58246   }
58247
58248   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58249
58250   //argout typemap for const std::string&
58251
58252   return jresult;
58253 }
58254
58255
58256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58257   void * jresult ;
58258   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58259   std::string *arg2 = 0 ;
58260   Dali::Property::Map *arg3 = 0 ;
58261   Dali::BaseHandle result;
58262
58263   arg1 = (Dali::Toolkit::Builder *)jarg1;
58264   if (!jarg2) {
58265     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58266     return 0;
58267   }
58268   std::string arg2_str(jarg2);
58269   arg2 = &arg2_str;
58270   arg3 = (Dali::Property::Map *)jarg3;
58271   if (!arg3) {
58272     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58273     return 0;
58274   }
58275   {
58276     try {
58277       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
58278     } catch (std::out_of_range& e) {
58279       {
58280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58281       };
58282     } catch (std::exception& e) {
58283       {
58284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58285       };
58286     } catch (Dali::DaliException e) {
58287       {
58288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58289       };
58290     } catch (...) {
58291       {
58292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58293       };
58294     }
58295   }
58296
58297   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58298
58299   //argout typemap for const std::string&
58300
58301   return jresult;
58302 }
58303
58304
58305 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
58306   void * jresult ;
58307   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58308   std::string *arg2 = 0 ;
58309   Dali::BaseHandle result;
58310
58311   arg1 = (Dali::Toolkit::Builder *)jarg1;
58312   if (!jarg2) {
58313     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58314     return 0;
58315   }
58316   std::string arg2_str(jarg2);
58317   arg2 = &arg2_str;
58318   {
58319     try {
58320       result = (arg1)->CreateFromJson((std::string const &)*arg2);
58321     } catch (std::out_of_range& e) {
58322       {
58323         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58324       };
58325     } catch (std::exception& e) {
58326       {
58327         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58328       };
58329     } catch (Dali::DaliException e) {
58330       {
58331         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58332       };
58333     } catch (...) {
58334       {
58335         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58336       };
58337     }
58338   }
58339
58340   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
58341
58342   //argout typemap for const std::string&
58343
58344   return jresult;
58345 }
58346
58347
58348 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
58349   unsigned int jresult ;
58350   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58351   std::string *arg2 = 0 ;
58352   Dali::Handle *arg3 = 0 ;
58353   bool result;
58354
58355   arg1 = (Dali::Toolkit::Builder *)jarg1;
58356   if (!jarg2) {
58357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58358     return 0;
58359   }
58360   std::string arg2_str(jarg2);
58361   arg2 = &arg2_str;
58362   arg3 = (Dali::Handle *)jarg3;
58363   if (!arg3) {
58364     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58365     return 0;
58366   }
58367   {
58368     try {
58369       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
58370     } catch (std::out_of_range& e) {
58371       {
58372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58373       };
58374     } catch (std::exception& e) {
58375       {
58376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58377       };
58378     } catch (Dali::DaliException e) {
58379       {
58380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58381       };
58382     } catch (...) {
58383       {
58384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58385       };
58386     }
58387   }
58388
58389   jresult = result;
58390
58391   //argout typemap for const std::string&
58392
58393   return jresult;
58394 }
58395
58396
58397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
58398   unsigned int jresult ;
58399   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58400   Dali::Handle *arg2 = 0 ;
58401   std::string *arg3 = 0 ;
58402   bool result;
58403
58404   arg1 = (Dali::Toolkit::Builder *)jarg1;
58405   arg2 = (Dali::Handle *)jarg2;
58406   if (!arg2) {
58407     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
58408     return 0;
58409   }
58410   if (!jarg3) {
58411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58412     return 0;
58413   }
58414   std::string arg3_str(jarg3);
58415   arg3 = &arg3_str;
58416   {
58417     try {
58418       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
58419     } catch (std::out_of_range& e) {
58420       {
58421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58422       };
58423     } catch (std::exception& e) {
58424       {
58425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58426       };
58427     } catch (Dali::DaliException e) {
58428       {
58429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58430       };
58431     } catch (...) {
58432       {
58433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58434       };
58435     }
58436   }
58437
58438   jresult = result;
58439
58440   //argout typemap for const std::string&
58441
58442   return jresult;
58443 }
58444
58445
58446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
58447   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58448   Dali::Actor arg2 ;
58449   Dali::Actor *argp2 ;
58450
58451   arg1 = (Dali::Toolkit::Builder *)jarg1;
58452   argp2 = (Dali::Actor *)jarg2;
58453   if (!argp2) {
58454     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58455     return ;
58456   }
58457   arg2 = *argp2;
58458   {
58459     try {
58460       (arg1)->AddActors(arg2);
58461     } catch (std::out_of_range& e) {
58462       {
58463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58464       };
58465     } catch (std::exception& e) {
58466       {
58467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58468       };
58469     } catch (Dali::DaliException e) {
58470       {
58471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58472       };
58473     } catch (...) {
58474       {
58475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58476       };
58477     }
58478   }
58479
58480 }
58481
58482
58483 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
58484   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58485   std::string *arg2 = 0 ;
58486   Dali::Actor arg3 ;
58487   Dali::Actor *argp3 ;
58488
58489   arg1 = (Dali::Toolkit::Builder *)jarg1;
58490   if (!jarg2) {
58491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58492     return ;
58493   }
58494   std::string arg2_str(jarg2);
58495   arg2 = &arg2_str;
58496   argp3 = (Dali::Actor *)jarg3;
58497   if (!argp3) {
58498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58499     return ;
58500   }
58501   arg3 = *argp3;
58502   {
58503     try {
58504       (arg1)->AddActors((std::string const &)*arg2,arg3);
58505     } catch (std::out_of_range& e) {
58506       {
58507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58508       };
58509     } catch (std::exception& e) {
58510       {
58511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58512       };
58513     } catch (Dali::DaliException e) {
58514       {
58515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58516       };
58517     } catch (...) {
58518       {
58519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58520       };
58521     }
58522   }
58523
58524
58525   //argout typemap for const std::string&
58526
58527 }
58528
58529
58530 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58531   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58532   std::string *arg2 = 0 ;
58533
58534   arg1 = (Dali::Toolkit::Builder *)jarg1;
58535   if (!jarg2) {
58536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58537     return ;
58538   }
58539   std::string arg2_str(jarg2);
58540   arg2 = &arg2_str;
58541   {
58542     try {
58543       (arg1)->CreateRenderTask((std::string const &)*arg2);
58544     } catch (std::out_of_range& e) {
58545       {
58546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58547       };
58548     } catch (std::exception& e) {
58549       {
58550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58551       };
58552     } catch (Dali::DaliException e) {
58553       {
58554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58555       };
58556     } catch (...) {
58557       {
58558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58559       };
58560     }
58561   }
58562
58563
58564   //argout typemap for const std::string&
58565
58566 }
58567
58568
58569 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58570   void * jresult ;
58571   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58572   std::string *arg2 = 0 ;
58573   Dali::Path result;
58574
58575   arg1 = (Dali::Toolkit::Builder *)jarg1;
58576   if (!jarg2) {
58577     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58578     return 0;
58579   }
58580   std::string arg2_str(jarg2);
58581   arg2 = &arg2_str;
58582   {
58583     try {
58584       result = (arg1)->GetPath((std::string const &)*arg2);
58585     } catch (std::out_of_range& e) {
58586       {
58587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58588       };
58589     } catch (std::exception& e) {
58590       {
58591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58592       };
58593     } catch (Dali::DaliException e) {
58594       {
58595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58596       };
58597     } catch (...) {
58598       {
58599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58600       };
58601     }
58602   }
58603
58604   jresult = new Dali::Path((const Dali::Path &)result);
58605
58606   //argout typemap for const std::string&
58607
58608   return jresult;
58609 }
58610
58611
58612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58613   void * jresult ;
58614   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58615   std::string *arg2 = 0 ;
58616   Dali::PathConstrainer result;
58617
58618   arg1 = (Dali::Toolkit::Builder *)jarg1;
58619   if (!jarg2) {
58620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58621     return 0;
58622   }
58623   std::string arg2_str(jarg2);
58624   arg2 = &arg2_str;
58625   {
58626     try {
58627       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58628     } catch (std::out_of_range& e) {
58629       {
58630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58631       };
58632     } catch (std::exception& e) {
58633       {
58634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58635       };
58636     } catch (Dali::DaliException e) {
58637       {
58638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58639       };
58640     } catch (...) {
58641       {
58642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58643       };
58644     }
58645   }
58646
58647   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58648
58649   //argout typemap for const std::string&
58650
58651   return jresult;
58652 }
58653
58654
58655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58656   void * jresult ;
58657   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58658   std::string *arg2 = 0 ;
58659   Dali::LinearConstrainer result;
58660
58661   arg1 = (Dali::Toolkit::Builder *)jarg1;
58662   if (!jarg2) {
58663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58664     return 0;
58665   }
58666   std::string arg2_str(jarg2);
58667   arg2 = &arg2_str;
58668   {
58669     try {
58670       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58671     } catch (std::out_of_range& e) {
58672       {
58673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58674       };
58675     } catch (std::exception& e) {
58676       {
58677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58678       };
58679     } catch (Dali::DaliException e) {
58680       {
58681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58682       };
58683     } catch (...) {
58684       {
58685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58686       };
58687     }
58688   }
58689
58690   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58691
58692   //argout typemap for const std::string&
58693
58694   return jresult;
58695 }
58696
58697
58698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58699   void * jresult ;
58700   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58701   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58702
58703   arg1 = (Dali::Toolkit::Builder *)jarg1;
58704   {
58705     try {
58706       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58707     } catch (std::out_of_range& e) {
58708       {
58709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58710       };
58711     } catch (std::exception& e) {
58712       {
58713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58714       };
58715     } catch (Dali::DaliException e) {
58716       {
58717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58718       };
58719     } catch (...) {
58720       {
58721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58722       };
58723     }
58724   }
58725
58726   jresult = (void *)result;
58727   return jresult;
58728 }
58729
58730
58731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58732   void * jresult ;
58733   Dali::Toolkit::TransitionData *result = 0 ;
58734
58735   {
58736     try {
58737       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58738     } catch (std::out_of_range& e) {
58739       {
58740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58741       };
58742     } catch (std::exception& e) {
58743       {
58744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58745       };
58746     } catch (Dali::DaliException e) {
58747       {
58748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58749       };
58750     } catch (...) {
58751       {
58752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58753       };
58754     }
58755   }
58756
58757   jresult = (void *)result;
58758   return jresult;
58759 }
58760
58761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58762   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58763
58764   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58765   {
58766     try {
58767       delete arg1;
58768     } catch (std::out_of_range& e) {
58769       {
58770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58771       };
58772     } catch (std::exception& e) {
58773       {
58774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58775       };
58776     } catch (Dali::DaliException e) {
58777       {
58778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58779       };
58780     } catch (...) {
58781       {
58782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58783       };
58784     }
58785   }
58786
58787 }
58788
58789
58790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58791   void * jresult ;
58792   Dali::Property::Map *arg1 = 0 ;
58793   Dali::Toolkit::TransitionData result;
58794
58795   arg1 = (Dali::Property::Map *)jarg1;
58796   if (!arg1) {
58797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58798     return 0;
58799   }
58800   {
58801     try {
58802       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58803     } catch (std::out_of_range& e) {
58804       {
58805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58806       };
58807     } catch (std::exception& e) {
58808       {
58809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58810       };
58811     } catch (Dali::DaliException e) {
58812       {
58813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58814       };
58815     } catch (...) {
58816       {
58817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58818       };
58819     }
58820   }
58821
58822   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58823   return jresult;
58824 }
58825
58826
58827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58828   void * jresult ;
58829   Dali::Property::Array *arg1 = 0 ;
58830   Dali::Toolkit::TransitionData result;
58831
58832   arg1 = (Dali::Property::Array *)jarg1;
58833   if (!arg1) {
58834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58835     return 0;
58836   }
58837   {
58838     try {
58839       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58840     } catch (std::out_of_range& e) {
58841       {
58842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58843       };
58844     } catch (std::exception& e) {
58845       {
58846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58847       };
58848     } catch (Dali::DaliException e) {
58849       {
58850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58851       };
58852     } catch (...) {
58853       {
58854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58855       };
58856     }
58857   }
58858
58859   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58860   return jresult;
58861 }
58862
58863
58864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58865   void * jresult ;
58866   Dali::BaseHandle arg1 ;
58867   Dali::BaseHandle *argp1 ;
58868   Dali::Toolkit::TransitionData result;
58869
58870   argp1 = (Dali::BaseHandle *)jarg1;
58871   if (!argp1) {
58872     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58873     return 0;
58874   }
58875   arg1 = *argp1;
58876   {
58877     try {
58878       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58879     } catch (std::out_of_range& e) {
58880       {
58881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58882       };
58883     } catch (std::exception& e) {
58884       {
58885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58886       };
58887     } catch (Dali::DaliException e) {
58888       {
58889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58890       };
58891     } catch (...) {
58892       {
58893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58894       };
58895     }
58896   }
58897
58898   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58899   return jresult;
58900 }
58901
58902
58903 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58904   void * jresult ;
58905   Dali::Toolkit::TransitionData *arg1 = 0 ;
58906   Dali::Toolkit::TransitionData *result = 0 ;
58907
58908   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58909   if (!arg1) {
58910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58911     return 0;
58912   }
58913   {
58914     try {
58915       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58916     } catch (std::out_of_range& e) {
58917       {
58918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58919       };
58920     } catch (std::exception& e) {
58921       {
58922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58923       };
58924     } catch (Dali::DaliException e) {
58925       {
58926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58927       };
58928     } catch (...) {
58929       {
58930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58931       };
58932     }
58933   }
58934
58935   jresult = (void *)result;
58936   return jresult;
58937 }
58938
58939
58940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58941   void * jresult ;
58942   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58943   Dali::Toolkit::TransitionData *arg2 = 0 ;
58944   Dali::Toolkit::TransitionData *result = 0 ;
58945
58946   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58947   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58948   if (!arg2) {
58949     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58950     return 0;
58951   }
58952   {
58953     try {
58954       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58955     } catch (std::out_of_range& e) {
58956       {
58957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58958       };
58959     } catch (std::exception& e) {
58960       {
58961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58962       };
58963     } catch (Dali::DaliException e) {
58964       {
58965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58966       };
58967     } catch (...) {
58968       {
58969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58970       };
58971     }
58972   }
58973
58974   jresult = (void *)result;
58975   return jresult;
58976 }
58977
58978
58979 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58980   unsigned long jresult ;
58981   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58982   size_t result;
58983
58984   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58985   {
58986     try {
58987       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58988     } catch (std::out_of_range& e) {
58989       {
58990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58991       };
58992     } catch (std::exception& e) {
58993       {
58994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58995       };
58996     } catch (Dali::DaliException e) {
58997       {
58998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58999       };
59000     } catch (...) {
59001       {
59002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59003       };
59004     }
59005   }
59006
59007   jresult = (unsigned long)result;
59008   return jresult;
59009 }
59010
59011
59012 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
59013   void * jresult ;
59014   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
59015   size_t arg2 ;
59016   Dali::Property::Map result;
59017
59018   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
59019   arg2 = (size_t)jarg2;
59020   {
59021     try {
59022       result = (arg1)->GetAnimatorAt(arg2);
59023     } catch (std::out_of_range& e) {
59024       {
59025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59026       };
59027     } catch (std::exception& e) {
59028       {
59029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59030       };
59031     } catch (Dali::DaliException e) {
59032       {
59033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59034       };
59035     } catch (...) {
59036       {
59037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59038       };
59039     }
59040   }
59041
59042   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
59043   return jresult;
59044 }
59045
59046
59047 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
59048   int jresult ;
59049   int result;
59050
59051   {
59052     try {
59053       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
59054     } catch (std::out_of_range& e) {
59055       {
59056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59057       };
59058     } catch (std::exception& e) {
59059       {
59060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59061       };
59062     } catch (Dali::DaliException e) {
59063       {
59064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59065       };
59066     } catch (...) {
59067       {
59068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59069       };
59070     }
59071   }
59072
59073   jresult = (int)result;
59074   return jresult;
59075 }
59076
59077
59078 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
59079   int jresult ;
59080   int result;
59081
59082   {
59083     try {
59084       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
59085     } catch (std::out_of_range& e) {
59086       {
59087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59088       };
59089     } catch (std::exception& e) {
59090       {
59091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59092       };
59093     } catch (Dali::DaliException e) {
59094       {
59095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59096       };
59097     } catch (...) {
59098       {
59099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59100       };
59101     }
59102   }
59103
59104   jresult = (int)result;
59105   return jresult;
59106 }
59107
59108
59109 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
59110   int jresult ;
59111   int result;
59112
59113   {
59114     try {
59115       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
59116     } catch (std::out_of_range& e) {
59117       {
59118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59119       };
59120     } catch (std::exception& e) {
59121       {
59122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59123       };
59124     } catch (Dali::DaliException e) {
59125       {
59126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59127       };
59128     } catch (...) {
59129       {
59130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59131       };
59132     }
59133   }
59134
59135   jresult = (int)result;
59136   return jresult;
59137 }
59138
59139
59140 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
59141   int jresult ;
59142   int result;
59143
59144   {
59145     try {
59146       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
59147     } catch (std::out_of_range& e) {
59148       {
59149         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59150       };
59151     } catch (std::exception& e) {
59152       {
59153         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59154       };
59155     } catch (Dali::DaliException e) {
59156       {
59157         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59158       };
59159     } catch (...) {
59160       {
59161         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59162       };
59163     }
59164   }
59165
59166   jresult = (int)result;
59167   return jresult;
59168 }
59169
59170
59171 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
59172   int jresult ;
59173   int result;
59174
59175   {
59176     try {
59177       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
59178     } catch (std::out_of_range& e) {
59179       {
59180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59181       };
59182     } catch (std::exception& e) {
59183       {
59184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59185       };
59186     } catch (Dali::DaliException e) {
59187       {
59188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59189       };
59190     } catch (...) {
59191       {
59192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59193       };
59194     }
59195   }
59196
59197   jresult = (int)result;
59198   return jresult;
59199 }
59200
59201
59202 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
59203   int jresult ;
59204   int result;
59205
59206   {
59207     try {
59208       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
59209     } catch (std::out_of_range& e) {
59210       {
59211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59212       };
59213     } catch (std::exception& e) {
59214       {
59215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59216       };
59217     } catch (Dali::DaliException e) {
59218       {
59219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59220       };
59221     } catch (...) {
59222       {
59223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59224       };
59225     }
59226   }
59227
59228   jresult = (int)result;
59229   return jresult;
59230 }
59231
59232
59233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
59234   int jresult ;
59235   int result;
59236
59237   {
59238     try {
59239       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
59240     } catch (std::out_of_range& e) {
59241       {
59242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59243       };
59244     } catch (std::exception& e) {
59245       {
59246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59247       };
59248     } catch (Dali::DaliException e) {
59249       {
59250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59251       };
59252     } catch (...) {
59253       {
59254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59255       };
59256     }
59257   }
59258
59259   jresult = (int)result;
59260   return jresult;
59261 }
59262
59263
59264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
59265   int jresult ;
59266   int result;
59267
59268   {
59269     try {
59270       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
59271     } catch (std::out_of_range& e) {
59272       {
59273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59274       };
59275     } catch (std::exception& e) {
59276       {
59277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59278       };
59279     } catch (Dali::DaliException e) {
59280       {
59281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59282       };
59283     } catch (...) {
59284       {
59285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59286       };
59287     }
59288   }
59289
59290   jresult = (int)result;
59291   return jresult;
59292 }
59293
59294
59295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
59296   int jresult ;
59297   int result;
59298
59299   {
59300     try {
59301       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
59302     } catch (std::out_of_range& e) {
59303       {
59304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59305       };
59306     } catch (std::exception& e) {
59307       {
59308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59309       };
59310     } catch (Dali::DaliException e) {
59311       {
59312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59313       };
59314     } catch (...) {
59315       {
59316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59317       };
59318     }
59319   }
59320
59321   jresult = (int)result;
59322   return jresult;
59323 }
59324
59325
59326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
59327   int jresult ;
59328   int result;
59329
59330   {
59331     try {
59332       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
59333     } catch (std::out_of_range& e) {
59334       {
59335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59336       };
59337     } catch (std::exception& e) {
59338       {
59339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59340       };
59341     } catch (Dali::DaliException e) {
59342       {
59343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59344       };
59345     } catch (...) {
59346       {
59347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59348       };
59349     }
59350   }
59351
59352   jresult = (int)result;
59353   return jresult;
59354 }
59355
59356
59357 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
59358   int jresult ;
59359   int result;
59360
59361   {
59362     try {
59363       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
59364     } catch (std::out_of_range& e) {
59365       {
59366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59367       };
59368     } catch (std::exception& e) {
59369       {
59370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59371       };
59372     } catch (Dali::DaliException e) {
59373       {
59374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59375       };
59376     } catch (...) {
59377       {
59378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59379       };
59380     }
59381   }
59382
59383   jresult = (int)result;
59384   return jresult;
59385 }
59386
59387
59388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
59389   int jresult ;
59390   int result;
59391
59392   {
59393     try {
59394       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
59395     } catch (std::out_of_range& e) {
59396       {
59397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59398       };
59399     } catch (std::exception& e) {
59400       {
59401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59402       };
59403     } catch (Dali::DaliException e) {
59404       {
59405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59406       };
59407     } catch (...) {
59408       {
59409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59410       };
59411     }
59412   }
59413
59414   jresult = (int)result;
59415   return jresult;
59416 }
59417
59418
59419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
59420   int jresult ;
59421   int result;
59422
59423   {
59424     try {
59425       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
59426     } catch (std::out_of_range& e) {
59427       {
59428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59429       };
59430     } catch (std::exception& e) {
59431       {
59432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59433       };
59434     } catch (Dali::DaliException e) {
59435       {
59436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59437       };
59438     } catch (...) {
59439       {
59440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59441       };
59442     }
59443   }
59444
59445   jresult = (int)result;
59446   return jresult;
59447 }
59448
59449
59450 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
59451   int jresult ;
59452   int result;
59453
59454   {
59455     try {
59456       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
59457     } catch (std::out_of_range& e) {
59458       {
59459         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59460       };
59461     } catch (std::exception& e) {
59462       {
59463         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59464       };
59465     } catch (Dali::DaliException e) {
59466       {
59467         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59468       };
59469     } catch (...) {
59470       {
59471         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59472       };
59473     }
59474   }
59475
59476   jresult = (int)result;
59477   return jresult;
59478 }
59479
59480
59481 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
59482   void * jresult ;
59483   Dali::Toolkit::Control result;
59484
59485   {
59486     try {
59487       result = Dali::Toolkit::Internal::Control::New();
59488     } catch (std::out_of_range& e) {
59489       {
59490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59491       };
59492     } catch (std::exception& e) {
59493       {
59494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59495       };
59496     } catch (Dali::DaliException e) {
59497       {
59498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59499       };
59500     } catch (...) {
59501       {
59502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59503       };
59504     }
59505   }
59506
59507   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59508   return jresult;
59509 }
59510
59511
59512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59513   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59514   std::string *arg2 = 0 ;
59515
59516   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59517   if (!jarg2) {
59518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59519     return ;
59520   }
59521   std::string arg2_str(jarg2);
59522   arg2 = &arg2_str;
59523   {
59524     try {
59525       (arg1)->SetStyleName((std::string const &)*arg2);
59526     } catch (std::out_of_range& e) {
59527       {
59528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59529       };
59530     } catch (std::exception& e) {
59531       {
59532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59533       };
59534     } catch (Dali::DaliException e) {
59535       {
59536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59537       };
59538     } catch (...) {
59539       {
59540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59541       };
59542     }
59543   }
59544
59545
59546   //argout typemap for const std::string&
59547
59548 }
59549
59550
59551 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59552   char * jresult ;
59553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59554   std::string *result = 0 ;
59555
59556   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59557   {
59558     try {
59559       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59560     } catch (std::out_of_range& e) {
59561       {
59562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59563       };
59564     } catch (std::exception& e) {
59565       {
59566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59567       };
59568     } catch (Dali::DaliException e) {
59569       {
59570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59571       };
59572     } catch (...) {
59573       {
59574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59575       };
59576     }
59577   }
59578
59579   jresult = SWIG_csharp_string_callback(result->c_str());
59580   return jresult;
59581 }
59582
59583
59584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59585   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59586   Dali::Vector4 *arg2 = 0 ;
59587
59588   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59589   arg2 = (Dali::Vector4 *)jarg2;
59590   if (!arg2) {
59591     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59592     return ;
59593   }
59594   {
59595     try {
59596       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59597     } catch (std::out_of_range& e) {
59598       {
59599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59600       };
59601     } catch (std::exception& e) {
59602       {
59603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59604       };
59605     } catch (Dali::DaliException e) {
59606       {
59607         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59608       };
59609     } catch (...) {
59610       {
59611         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59612       };
59613     }
59614   }
59615
59616 }
59617
59618
59619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59620   void * jresult ;
59621   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59622   Dali::Vector4 result;
59623
59624   arg1 = (Dali::Handle *)jarg1;
59625   {
59626     try {
59627       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59628       if (resultMap)
59629       {
59630         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59631         if(type && type->Get<int>() == Visual::COLOR )
59632         {
59633           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59634           if (value)
59635           {
59636             result = value->Get<Vector4>();
59637           }
59638         }
59639       }
59640     } catch (std::out_of_range& e) {
59641       {
59642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59643       };
59644     } catch (std::exception& e) {
59645       {
59646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59647       };
59648     } catch (Dali::DaliException e) {
59649       {
59650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59651       };
59652     } catch (...) {
59653       {
59654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59655       };
59656     }
59657   }
59658
59659   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59660   return jresult;
59661 }
59662
59663
59664 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59665   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59666   Dali::Property::Map *arg2 = 0 ;
59667
59668   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59669   arg2 = (Dali::Property::Map *)jarg2;
59670   if (!arg2) {
59671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59672     return ;
59673   }
59674   {
59675     try {
59676       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59677     } catch (std::out_of_range& e) {
59678       {
59679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59680       };
59681     } catch (std::exception& e) {
59682       {
59683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59684       };
59685     } catch (Dali::DaliException e) {
59686       {
59687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59688       };
59689     } catch (...) {
59690       {
59691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59692       };
59693     }
59694   }
59695
59696 }
59697
59698
59699 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59701
59702   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59703   {
59704     try {
59705       (arg1)->ClearBackground();
59706     } catch (std::out_of_range& e) {
59707       {
59708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59709       };
59710     } catch (std::exception& e) {
59711       {
59712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59713       };
59714     } catch (Dali::DaliException e) {
59715       {
59716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59717       };
59718     } catch (...) {
59719       {
59720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59721       };
59722     }
59723   }
59724
59725 }
59726
59727
59728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59729   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59730   Dali::Gesture::Type arg2 ;
59731
59732   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59733   arg2 = (Dali::Gesture::Type)jarg2;
59734   {
59735     try {
59736       (arg1)->EnableGestureDetection(arg2);
59737     } catch (std::out_of_range& e) {
59738       {
59739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59740       };
59741     } catch (std::exception& e) {
59742       {
59743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59744       };
59745     } catch (Dali::DaliException e) {
59746       {
59747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59748       };
59749     } catch (...) {
59750       {
59751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59752       };
59753     }
59754   }
59755
59756 }
59757
59758
59759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59760   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59761   Dali::Gesture::Type arg2 ;
59762
59763   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59764   arg2 = (Dali::Gesture::Type)jarg2;
59765   {
59766     try {
59767       (arg1)->DisableGestureDetection(arg2);
59768     } catch (std::out_of_range& e) {
59769       {
59770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59771       };
59772     } catch (std::exception& e) {
59773       {
59774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59775       };
59776     } catch (Dali::DaliException e) {
59777       {
59778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59779       };
59780     } catch (...) {
59781       {
59782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59783       };
59784     }
59785   }
59786
59787 }
59788
59789
59790 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59791   void * jresult ;
59792   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59793   Dali::PinchGestureDetector result;
59794
59795   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59796   {
59797     try {
59798       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59799     } catch (std::out_of_range& e) {
59800       {
59801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59802       };
59803     } catch (std::exception& e) {
59804       {
59805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59806       };
59807     } catch (Dali::DaliException e) {
59808       {
59809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59810       };
59811     } catch (...) {
59812       {
59813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59814       };
59815     }
59816   }
59817
59818   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59819   return jresult;
59820 }
59821
59822
59823 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59824   void * jresult ;
59825   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59826   Dali::PanGestureDetector result;
59827
59828   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59829   {
59830     try {
59831       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59832     } catch (std::out_of_range& e) {
59833       {
59834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59835       };
59836     } catch (std::exception& e) {
59837       {
59838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59839       };
59840     } catch (Dali::DaliException e) {
59841       {
59842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59843       };
59844     } catch (...) {
59845       {
59846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59847       };
59848     }
59849   }
59850
59851   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59852   return jresult;
59853 }
59854
59855
59856 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59857   void * jresult ;
59858   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59859   Dali::TapGestureDetector result;
59860
59861   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59862   {
59863     try {
59864       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59865     } catch (std::out_of_range& e) {
59866       {
59867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59868       };
59869     } catch (std::exception& e) {
59870       {
59871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59872       };
59873     } catch (Dali::DaliException e) {
59874       {
59875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59876       };
59877     } catch (...) {
59878       {
59879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59880       };
59881     }
59882   }
59883
59884   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59885   return jresult;
59886 }
59887
59888
59889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59890   void * jresult ;
59891   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59892   Dali::LongPressGestureDetector result;
59893
59894   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59895   {
59896     try {
59897       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59898     } catch (std::out_of_range& e) {
59899       {
59900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59901       };
59902     } catch (std::exception& e) {
59903       {
59904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59905       };
59906     } catch (Dali::DaliException e) {
59907       {
59908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59909       };
59910     } catch (...) {
59911       {
59912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59913       };
59914     }
59915   }
59916
59917   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59918   return jresult;
59919 }
59920
59921
59922 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59923   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59924   bool arg2 ;
59925
59926   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59927   arg2 = jarg2 ? true : false;
59928   {
59929     try {
59930       (arg1)->SetKeyboardNavigationSupport(arg2);
59931     } catch (std::out_of_range& e) {
59932       {
59933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59934       };
59935     } catch (std::exception& e) {
59936       {
59937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59938       };
59939     } catch (Dali::DaliException e) {
59940       {
59941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59942       };
59943     } catch (...) {
59944       {
59945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59946       };
59947     }
59948   }
59949
59950 }
59951
59952
59953 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59954   unsigned int jresult ;
59955   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59956   bool result;
59957
59958   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59959   {
59960     try {
59961       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59962     } catch (std::out_of_range& e) {
59963       {
59964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59965       };
59966     } catch (std::exception& e) {
59967       {
59968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59969       };
59970     } catch (Dali::DaliException e) {
59971       {
59972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59973       };
59974     } catch (...) {
59975       {
59976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59977       };
59978     }
59979   }
59980
59981   jresult = result;
59982   return jresult;
59983 }
59984
59985
59986 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59987   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59988
59989   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59990   {
59991     try {
59992       (arg1)->SetKeyInputFocus();
59993     } catch (std::out_of_range& e) {
59994       {
59995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59996       };
59997     } catch (std::exception& e) {
59998       {
59999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60000       };
60001     } catch (Dali::DaliException e) {
60002       {
60003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60004       };
60005     } catch (...) {
60006       {
60007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60008       };
60009     }
60010   }
60011
60012 }
60013
60014
60015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
60016   unsigned int jresult ;
60017   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60018   bool result;
60019
60020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60021   {
60022     try {
60023       result = (bool)(arg1)->HasKeyInputFocus();
60024     } catch (std::out_of_range& e) {
60025       {
60026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60027       };
60028     } catch (std::exception& e) {
60029       {
60030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60031       };
60032     } catch (Dali::DaliException e) {
60033       {
60034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60035       };
60036     } catch (...) {
60037       {
60038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60039       };
60040     }
60041   }
60042
60043   jresult = result;
60044   return jresult;
60045 }
60046
60047
60048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
60049   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60050
60051   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60052   {
60053     try {
60054       (arg1)->ClearKeyInputFocus();
60055     } catch (std::out_of_range& e) {
60056       {
60057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60058       };
60059     } catch (std::exception& e) {
60060       {
60061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60062       };
60063     } catch (Dali::DaliException e) {
60064       {
60065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60066       };
60067     } catch (...) {
60068       {
60069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60070       };
60071     }
60072   }
60073
60074 }
60075
60076
60077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
60078   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60079   bool arg2 ;
60080
60081   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60082   arg2 = jarg2 ? true : false;
60083   {
60084     try {
60085       (arg1)->SetAsKeyboardFocusGroup(arg2);
60086     } catch (std::out_of_range& e) {
60087       {
60088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60089       };
60090     } catch (std::exception& e) {
60091       {
60092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60093       };
60094     } catch (Dali::DaliException e) {
60095       {
60096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60097       };
60098     } catch (...) {
60099       {
60100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60101       };
60102     }
60103   }
60104
60105 }
60106
60107
60108 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
60109   unsigned int jresult ;
60110   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60111   bool result;
60112
60113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60114   {
60115     try {
60116       result = (bool)(arg1)->IsKeyboardFocusGroup();
60117     } catch (std::out_of_range& e) {
60118       {
60119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60120       };
60121     } catch (std::exception& e) {
60122       {
60123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60124       };
60125     } catch (Dali::DaliException e) {
60126       {
60127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60128       };
60129     } catch (...) {
60130       {
60131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60132       };
60133     }
60134   }
60135
60136   jresult = result;
60137   return jresult;
60138 }
60139
60140
60141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
60142   void * jresult ;
60143   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60144   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
60145
60146   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60147   {
60148     try {
60149       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
60150     } catch (std::out_of_range& e) {
60151       {
60152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60153       };
60154     } catch (std::exception& e) {
60155       {
60156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60157       };
60158     } catch (Dali::DaliException e) {
60159       {
60160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60161       };
60162     } catch (...) {
60163       {
60164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60165       };
60166     }
60167   }
60168
60169   jresult = (void *)result;
60170   return jresult;
60171 }
60172
60173
60174 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
60175   void * jresult ;
60176   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60177   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60178
60179   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60180   {
60181     try {
60182       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
60183     } catch (std::out_of_range& e) {
60184       {
60185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60186       };
60187     } catch (std::exception& e) {
60188       {
60189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60190       };
60191     } catch (Dali::DaliException e) {
60192       {
60193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60194       };
60195     } catch (...) {
60196       {
60197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60198       };
60199     }
60200   }
60201
60202   jresult = (void *)result;
60203   return jresult;
60204 }
60205
60206
60207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
60208   void * jresult ;
60209   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60210   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
60211
60212   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60213   {
60214     try {
60215       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
60216     } catch (std::out_of_range& e) {
60217       {
60218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60219       };
60220     } catch (std::exception& e) {
60221       {
60222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60223       };
60224     } catch (Dali::DaliException e) {
60225       {
60226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60227       };
60228     } catch (...) {
60229       {
60230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60231       };
60232     }
60233   }
60234
60235   jresult = (void *)result;
60236   return jresult;
60237 }
60238
60239
60240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
60241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60242   int arg2 ;
60243   SwigDirector_ViewImpl *darg = 0;
60244
60245   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60246   arg2 = (int)jarg2;
60247   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60248   if(!darg) {
60249     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60250     return;
60251   }
60252   {
60253     try {
60254       if(darg) {
60255         (darg)->OnStageConnection(arg2);
60256       }
60257     } catch (std::out_of_range& e) {
60258       {
60259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60260       };
60261     } catch (std::exception& e) {
60262       {
60263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60264       };
60265     } catch (Dali::DaliException e) {
60266       {
60267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60268       };
60269     } catch (...) {
60270       {
60271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60272       };
60273     }
60274   }
60275
60276 }
60277
60278
60279 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
60280   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60281   int arg2 ;
60282   SwigDirector_ViewImpl *darg = 0;
60283
60284   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60285   arg2 = (int)jarg2;
60286   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60287   if(!darg) {
60288     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60289     return;
60290   }
60291   {
60292     try {
60293       if(darg) {
60294         (darg)->OnStageConnectionSwigPublic(arg2);
60295       }
60296     } catch (std::out_of_range& e) {
60297       {
60298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60299       };
60300     } catch (std::exception& e) {
60301       {
60302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60303       };
60304     } catch (Dali::DaliException e) {
60305       {
60306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60307       };
60308     } catch (...) {
60309       {
60310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60311       };
60312     }
60313   }
60314
60315 }
60316
60317
60318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
60319   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60320   SwigDirector_ViewImpl *darg = 0;
60321
60322   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60323   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60324   if(!darg) {
60325     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60326     return;
60327   }
60328   {
60329     try {
60330       if(darg) {
60331         (darg)->OnStageDisconnection();
60332       }
60333     } catch (std::out_of_range& e) {
60334       {
60335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60336       };
60337     } catch (std::exception& e) {
60338       {
60339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60340       };
60341     } catch (Dali::DaliException e) {
60342       {
60343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60344       };
60345     } catch (...) {
60346       {
60347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60348       };
60349     }
60350   }
60351
60352 }
60353
60354
60355 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
60356   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60357   SwigDirector_ViewImpl *darg = 0;
60358
60359   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60360   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60361   if(!darg) {
60362     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60363     return;
60364   }
60365   {
60366     try {
60367       if(darg) {
60368         (darg)->OnStageDisconnectionSwigPublic();
60369       }
60370     } catch (std::out_of_range& e) {
60371       {
60372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60373       };
60374     } catch (std::exception& e) {
60375       {
60376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60377       };
60378     } catch (Dali::DaliException e) {
60379       {
60380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60381       };
60382     } catch (...) {
60383       {
60384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60385       };
60386     }
60387   }
60388
60389 }
60390
60391
60392 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
60393   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60394   Dali::Actor *arg2 = 0 ;
60395   SwigDirector_ViewImpl *darg = 0;
60396
60397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60398   arg2 = (Dali::Actor *)jarg2;
60399   if (!arg2) {
60400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60401     return ;
60402   }
60403   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60404   if(!darg) {
60405     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60406     return;
60407   }
60408   {
60409     try {
60410       if(darg) {
60411         (darg)->OnChildAdd(*arg2);
60412       }
60413     } catch (std::out_of_range& e) {
60414       {
60415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60416       };
60417     } catch (std::exception& e) {
60418       {
60419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60420       };
60421     } catch (Dali::DaliException e) {
60422       {
60423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60424       };
60425     } catch (...) {
60426       {
60427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60428       };
60429     }
60430   }
60431
60432 }
60433
60434
60435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60436   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60437   Dali::Actor *arg2 = 0 ;
60438   SwigDirector_ViewImpl *darg = 0;
60439
60440   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60441   arg2 = (Dali::Actor *)jarg2;
60442   if (!arg2) {
60443     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60444     return ;
60445   }
60446   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60447   if(!darg) {
60448     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60449     return;
60450   }
60451   {
60452     try {
60453       if(darg) {
60454           (darg)->OnChildAddSwigPublic(*arg2);
60455       }
60456     } catch (std::out_of_range& e) {
60457       {
60458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60459       };
60460     } catch (std::exception& e) {
60461       {
60462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60463       };
60464     } catch (Dali::DaliException e) {
60465       {
60466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60467       };
60468     } catch (...) {
60469       {
60470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60471       };
60472     }
60473   }
60474
60475 }
60476
60477
60478 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
60479   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60480   Dali::Actor *arg2 = 0 ;
60481   SwigDirector_ViewImpl *darg = 0;
60482
60483   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60484   arg2 = (Dali::Actor *)jarg2;
60485   if (!arg2) {
60486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60487     return ;
60488   }
60489   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60490   if(!darg) {
60491     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60492     return;
60493   }
60494   {
60495     try {
60496       if(darg) {
60497         (darg)->OnChildRemove(*arg2);
60498       }
60499     } catch (std::out_of_range& e) {
60500       {
60501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60502       };
60503     } catch (std::exception& e) {
60504       {
60505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60506       };
60507     } catch (Dali::DaliException e) {
60508       {
60509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60510       };
60511     } catch (...) {
60512       {
60513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60514       };
60515     }
60516   }
60517
60518 }
60519
60520
60521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60522   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60523   Dali::Actor *arg2 = 0 ;
60524   SwigDirector_ViewImpl *darg = 0;
60525
60526   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60527   arg2 = (Dali::Actor *)jarg2;
60528   if (!arg2) {
60529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60530     return ;
60531   }
60532   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60533   if(!darg) {
60534     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60535     return;
60536   }
60537   {
60538     try {
60539       if(darg) {
60540         (darg)->OnChildRemoveSwigPublic(*arg2);
60541       }
60542     } catch (std::out_of_range& e) {
60543       {
60544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60545       };
60546     } catch (std::exception& e) {
60547       {
60548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60549       };
60550     } catch (Dali::DaliException e) {
60551       {
60552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60553       };
60554     } catch (...) {
60555       {
60556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60557       };
60558     }
60559   }
60560
60561 }
60562
60563
60564 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60565   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60566   Dali::Property::Index arg2 ;
60567   Dali::Property::Value arg3 ;
60568   Dali::Property::Value *argp3 ;
60569   SwigDirector_ViewImpl *darg = 0;
60570
60571   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60572   arg2 = (Dali::Property::Index)jarg2;
60573   argp3 = (Dali::Property::Value *)jarg3;
60574   if (!argp3) {
60575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60576     return ;
60577   }
60578   arg3 = *argp3;
60579   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60580   if (!darg) {
60581     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60582     return;
60583   }
60584   {
60585     try {
60586       (darg)->OnPropertySet(arg2,arg3);
60587     } catch (std::out_of_range& e) {
60588       {
60589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60590       };
60591     } catch (std::exception& e) {
60592       {
60593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60594       };
60595     } catch (Dali::DaliException e) {
60596       {
60597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60598       };
60599     } catch (...) {
60600       {
60601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60602       };
60603     }
60604   }
60605
60606 }
60607
60608
60609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60610   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60611   Dali::Property::Index arg2 ;
60612   Dali::Property::Value arg3 ;
60613   Dali::Property::Value *argp3 ;
60614   SwigDirector_ViewImpl *darg = 0;
60615
60616   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60617   arg2 = (Dali::Property::Index)jarg2;
60618   argp3 = (Dali::Property::Value *)jarg3;
60619   if (!argp3) {
60620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60621     return ;
60622   }
60623   arg3 = *argp3;
60624   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60625   if (!darg) {
60626     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60627     return;
60628   }
60629   {
60630     try {
60631       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60632     } catch (std::out_of_range& e) {
60633       {
60634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60635       };
60636     } catch (std::exception& e) {
60637       {
60638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60639       };
60640     } catch (Dali::DaliException e) {
60641       {
60642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60643       };
60644     } catch (...) {
60645       {
60646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60647       };
60648     }
60649   }
60650
60651 }
60652
60653
60654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60655   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60656   Dali::Vector3 *arg2 = 0 ;
60657   SwigDirector_ViewImpl *darg = 0;
60658
60659   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60660   arg2 = (Dali::Vector3 *)jarg2;
60661   if (!arg2) {
60662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60663     return ;
60664   }
60665   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60666   if (!darg) {
60667     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60668     return;
60669   }
60670   {
60671     try {
60672       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60673     } catch (std::out_of_range& e) {
60674       {
60675         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60676       };
60677     } catch (std::exception& e) {
60678       {
60679         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60680       };
60681     } catch (Dali::DaliException e) {
60682       {
60683         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60684       };
60685     } catch (...) {
60686       {
60687         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60688       };
60689     }
60690   }
60691
60692 }
60693
60694
60695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60696   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60697   Dali::Vector3 *arg2 = 0 ;
60698   SwigDirector_ViewImpl *darg = 0;
60699
60700   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60701   arg2 = (Dali::Vector3 *)jarg2;
60702   if (!arg2) {
60703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60704     return ;
60705   }
60706   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60707   if (!darg) {
60708     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60709     return;
60710   }
60711   {
60712     try {
60713       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60714     } catch (std::out_of_range& e) {
60715       {
60716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60717       };
60718     } catch (std::exception& e) {
60719       {
60720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60721       };
60722     } catch (Dali::DaliException e) {
60723       {
60724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60725       };
60726     } catch (...) {
60727       {
60728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60729       };
60730     }
60731   }
60732
60733 }
60734
60735
60736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60737   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60738   Dali::Animation *arg2 = 0 ;
60739   Dali::Vector3 *arg3 = 0 ;
60740   SwigDirector_ViewImpl *darg = 0;
60741
60742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60743   arg2 = (Dali::Animation *)jarg2;
60744   if (!arg2) {
60745     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60746     return ;
60747   }
60748   arg3 = (Dali::Vector3 *)jarg3;
60749   if (!arg3) {
60750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60751     return ;
60752   }
60753   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60754   if (!darg) {
60755     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60756     return;
60757   }
60758   {
60759     try {
60760       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60761     } catch (std::out_of_range& e) {
60762       {
60763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60764       };
60765     } catch (std::exception& e) {
60766       {
60767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60768       };
60769     } catch (Dali::DaliException e) {
60770       {
60771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60772       };
60773     } catch (...) {
60774       {
60775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60776       };
60777     }
60778   }
60779
60780 }
60781
60782
60783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60785   Dali::Animation *arg2 = 0 ;
60786   Dali::Vector3 *arg3 = 0 ;
60787   SwigDirector_ViewImpl *darg = 0;
60788
60789   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60790   arg2 = (Dali::Animation *)jarg2;
60791   if (!arg2) {
60792     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60793     return ;
60794   }
60795   arg3 = (Dali::Vector3 *)jarg3;
60796   if (!arg3) {
60797     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60798     return ;
60799   }
60800   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60801   if (!darg) {
60802     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60803     return;
60804   }
60805   {
60806     try {
60807       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60808     } catch (std::out_of_range& e) {
60809       {
60810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60811       };
60812     } catch (std::exception& e) {
60813       {
60814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60815       };
60816     } catch (Dali::DaliException e) {
60817       {
60818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60819       };
60820     } catch (...) {
60821       {
60822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60823       };
60824     }
60825   }
60826
60827 }
60828
60829
60830 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60831   unsigned int jresult ;
60832   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60833   Dali::TouchEvent *arg2 = 0 ;
60834   SwigDirector_ViewImpl *darg = 0;
60835   bool result;
60836
60837   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60838   arg2 = (Dali::TouchEvent *)jarg2;
60839   if (!arg2) {
60840     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60841     return 0;
60842   }
60843   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60844   if (!darg) {
60845     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60846     return 0;
60847   }
60848   {
60849     try {
60850       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60851     } catch (std::out_of_range& e) {
60852       {
60853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60854       };
60855     } catch (std::exception& e) {
60856       {
60857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60858       };
60859     } catch (Dali::DaliException e) {
60860       {
60861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60862       };
60863     } catch (...) {
60864       {
60865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60866       };
60867     }
60868   }
60869
60870   jresult = result;
60871   return jresult;
60872 }
60873
60874
60875 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60876   unsigned int jresult ;
60877   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60878   Dali::TouchEvent *arg2 = 0 ;
60879   SwigDirector_ViewImpl *darg = 0;
60880   bool result;
60881
60882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60883   arg2 = (Dali::TouchEvent *)jarg2;
60884   if (!arg2) {
60885     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60886     return 0;
60887   }
60888   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60889   if (!darg) {
60890     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60891     return 0;
60892   }
60893   {
60894     try {
60895       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
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 = result;
60916   return jresult;
60917 }
60918
60919
60920 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60921   unsigned int jresult ;
60922   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60923   Dali::HoverEvent *arg2 = 0 ;
60924   SwigDirector_ViewImpl *darg = 0;
60925   bool result;
60926
60927   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60928   arg2 = (Dali::HoverEvent *)jarg2;
60929   if (!arg2) {
60930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60931     return 0;
60932   }
60933   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60934   if (!darg) {
60935     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60936     return 0;
60937   }
60938   {
60939     try {
60940       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60941     } catch (std::out_of_range& e) {
60942       {
60943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60944       };
60945     } catch (std::exception& e) {
60946       {
60947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60948       };
60949     } catch (Dali::DaliException e) {
60950       {
60951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60952       };
60953     } catch (...) {
60954       {
60955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60956       };
60957     }
60958   }
60959
60960   jresult = result;
60961   return jresult;
60962 }
60963
60964
60965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60966   unsigned int jresult ;
60967   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60968   Dali::HoverEvent *arg2 = 0 ;
60969   SwigDirector_ViewImpl *darg = 0;
60970   bool result;
60971
60972   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60973   arg2 = (Dali::HoverEvent *)jarg2;
60974   if (!arg2) {
60975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60976     return 0;
60977   }
60978   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60979   if (!darg) {
60980     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60981     return 0;
60982   }
60983   {
60984     try {
60985       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60986     } catch (std::out_of_range& e) {
60987       {
60988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60989       };
60990     } catch (std::exception& e) {
60991       {
60992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60993       };
60994     } catch (Dali::DaliException e) {
60995       {
60996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60997       };
60998     } catch (...) {
60999       {
61000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61001       };
61002     }
61003   }
61004
61005   jresult = result;
61006   return jresult;
61007 }
61008
61009
61010 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
61011   unsigned int jresult ;
61012   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61013   Dali::KeyEvent *arg2 = 0 ;
61014   SwigDirector_ViewImpl *darg = 0;
61015   bool result;
61016
61017   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61018   arg2 = (Dali::KeyEvent *)jarg2;
61019   if (!arg2) {
61020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61021     return 0;
61022   }
61023   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61024   if (!darg) {
61025     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61026     return 0;
61027   }
61028   {
61029     try {
61030       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
61031     } catch (std::out_of_range& e) {
61032       {
61033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61034       };
61035     } catch (std::exception& e) {
61036       {
61037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61038       };
61039     } catch (Dali::DaliException e) {
61040       {
61041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61042       };
61043     } catch (...) {
61044       {
61045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61046       };
61047     }
61048   }
61049
61050   jresult = result;
61051   return jresult;
61052 }
61053
61054
61055 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61056   unsigned int jresult ;
61057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61058   Dali::KeyEvent *arg2 = 0 ;
61059   SwigDirector_ViewImpl *darg = 0;
61060   bool result;
61061
61062   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61063   arg2 = (Dali::KeyEvent *)jarg2;
61064   if (!arg2) {
61065     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
61066     return 0;
61067   }
61068   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61069   if (!darg) {
61070     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61071     return 0;
61072   }
61073   {
61074     try {
61075       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
61076     } catch (std::out_of_range& e) {
61077       {
61078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61079       };
61080     } catch (std::exception& e) {
61081       {
61082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61083       };
61084     } catch (Dali::DaliException e) {
61085       {
61086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61087       };
61088     } catch (...) {
61089       {
61090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61091       };
61092     }
61093   }
61094
61095   jresult = result;
61096   return jresult;
61097 }
61098
61099
61100 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
61101   unsigned int jresult ;
61102   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61103   Dali::WheelEvent *arg2 = 0 ;
61104   SwigDirector_ViewImpl *darg = 0;
61105   bool result;
61106
61107   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61108   arg2 = (Dali::WheelEvent *)jarg2;
61109   if (!arg2) {
61110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61111     return 0;
61112   }
61113   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61114   if (!darg) {
61115     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61116     return 0;
61117   }
61118   {
61119     try {
61120       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
61121     } catch (std::out_of_range& e) {
61122       {
61123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61124       };
61125     } catch (std::exception& e) {
61126       {
61127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61128       };
61129     } catch (Dali::DaliException e) {
61130       {
61131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61132       };
61133     } catch (...) {
61134       {
61135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61136       };
61137     }
61138   }
61139
61140   jresult = result;
61141   return jresult;
61142 }
61143
61144
61145 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61146   unsigned int jresult ;
61147   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61148   Dali::WheelEvent *arg2 = 0 ;
61149   SwigDirector_ViewImpl *darg = 0;
61150   bool result;
61151
61152   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61153   arg2 = (Dali::WheelEvent *)jarg2;
61154   if (!arg2) {
61155     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
61156     return 0;
61157   }
61158   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61159   if (!darg) {
61160     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61161     return 0;
61162   }
61163   {
61164     try {
61165       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
61166     } catch (std::out_of_range& e) {
61167       {
61168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61169       };
61170     } catch (std::exception& e) {
61171       {
61172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61173       };
61174     } catch (Dali::DaliException e) {
61175       {
61176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61177       };
61178     } catch (...) {
61179       {
61180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61181       };
61182     }
61183   }
61184
61185   jresult = result;
61186   return jresult;
61187 }
61188
61189
61190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
61191   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61192   Dali::Vector2 *arg2 = 0 ;
61193   Dali::RelayoutContainer *arg3 = 0 ;
61194   SwigDirector_ViewImpl *darg = 0;
61195
61196   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61197   arg2 = (Dali::Vector2 *)jarg2;
61198   if (!arg2) {
61199     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61200     return ;
61201   }
61202   arg3 = (Dali::RelayoutContainer *)jarg3;
61203   if (!arg3) {
61204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61205     return ;
61206   }
61207   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61208   if (!darg) {
61209     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61210     return;
61211   }
61212   {
61213     try {
61214       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
61215     } catch (std::out_of_range& e) {
61216       {
61217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61218       };
61219     } catch (std::exception& e) {
61220       {
61221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61222       };
61223     } catch (Dali::DaliException e) {
61224       {
61225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61226       };
61227     } catch (...) {
61228       {
61229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61230       };
61231     }
61232   }
61233
61234 }
61235
61236
61237 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
61238   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61239   Dali::Vector2 *arg2 = 0 ;
61240   Dali::RelayoutContainer *arg3 = 0 ;
61241   SwigDirector_ViewImpl *darg = 0;
61242
61243   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61244   arg2 = (Dali::Vector2 *)jarg2;
61245   if (!arg2) {
61246     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
61247     return ;
61248   }
61249   arg3 = (Dali::RelayoutContainer *)jarg3;
61250   if (!arg3) {
61251     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
61252     return ;
61253   }
61254   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61255   if (!darg) {
61256     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61257     return;
61258   }
61259   {
61260     try {
61261       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
61262     } catch (std::out_of_range& e) {
61263       {
61264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61265       };
61266     } catch (std::exception& e) {
61267       {
61268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61269       };
61270     } catch (Dali::DaliException e) {
61271       {
61272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61273       };
61274     } catch (...) {
61275       {
61276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61277       };
61278     }
61279   }
61280
61281 }
61282
61283
61284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
61285   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61286   Dali::ResizePolicy::Type arg2 ;
61287   Dali::Dimension::Type arg3 ;
61288   SwigDirector_ViewImpl *darg = 0;
61289
61290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61291   arg2 = (Dali::ResizePolicy::Type)jarg2;
61292   arg3 = (Dali::Dimension::Type)jarg3;
61293   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61294   if (!darg) {
61295     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61296     return;
61297   }
61298   {
61299     try {
61300       (darg)->OnSetResizePolicy(arg2,arg3);
61301     } catch (std::out_of_range& e) {
61302       {
61303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61304       };
61305     } catch (std::exception& e) {
61306       {
61307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61308       };
61309     } catch (Dali::DaliException e) {
61310       {
61311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61312       };
61313     } catch (...) {
61314       {
61315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61316       };
61317     }
61318   }
61319
61320 }
61321
61322
61323 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
61324   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61325   Dali::ResizePolicy::Type arg2 ;
61326   Dali::Dimension::Type arg3 ;
61327   SwigDirector_ViewImpl *darg = 0;
61328
61329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61330   arg2 = (Dali::ResizePolicy::Type)jarg2;
61331   arg3 = (Dali::Dimension::Type)jarg3;
61332   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61333   if (!darg) {
61334     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61335     return;
61336   }
61337   {
61338     try {
61339       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
61340     } catch (std::out_of_range& e) {
61341       {
61342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61343       };
61344     } catch (std::exception& e) {
61345       {
61346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61347       };
61348     } catch (Dali::DaliException e) {
61349       {
61350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61351       };
61352     } catch (...) {
61353       {
61354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61355       };
61356     }
61357   }
61358
61359 }
61360
61361
61362 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
61363   void * jresult ;
61364   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61365   SwigDirector_ViewImpl *darg = 0;
61366   Dali::Vector3 result;
61367
61368   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61369   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61370   if (!darg) {
61371     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61372     return 0;
61373   }
61374   {
61375     try {
61376       result = (darg)->GetNaturalSize();
61377     } catch (std::out_of_range& e) {
61378       {
61379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61380       };
61381     } catch (std::exception& e) {
61382       {
61383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61384       };
61385     } catch (Dali::DaliException e) {
61386       {
61387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61388       };
61389     } catch (...) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61392       };
61393     }
61394   }
61395
61396   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61397   return jresult;
61398 }
61399
61400
61401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
61402   void * jresult ;
61403   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61404   SwigDirector_ViewImpl *darg = 0;
61405   Dali::Vector3 result;
61406
61407   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61408   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61409   if (!darg) {
61410     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61411     return 0;
61412   }
61413   {
61414     try {
61415       result = (darg)->GetNaturalSizeSwigPublic();
61416     } catch (std::out_of_range& e) {
61417       {
61418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61419       };
61420     } catch (std::exception& e) {
61421       {
61422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61423       };
61424     } catch (Dali::DaliException e) {
61425       {
61426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61427       };
61428     } catch (...) {
61429       {
61430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61431       };
61432     }
61433   }
61434
61435   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
61436   return jresult;
61437 }
61438
61439
61440 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
61441   float jresult ;
61442   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61443   Dali::Actor *arg2 = 0 ;
61444   Dali::Dimension::Type arg3 ;
61445   SwigDirector_ViewImpl *darg = 0;
61446   float result;
61447
61448   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61449   arg2 = (Dali::Actor *)jarg2;
61450   if (!arg2) {
61451     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61452     return 0;
61453   }
61454   arg3 = (Dali::Dimension::Type)jarg3;
61455   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61456   if (!darg) {
61457     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61458     return 0;
61459   }
61460   {
61461     try {
61462       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
61463     } catch (std::out_of_range& e) {
61464       {
61465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61466       };
61467     } catch (std::exception& e) {
61468       {
61469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61470       };
61471     } catch (Dali::DaliException e) {
61472       {
61473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61474       };
61475     } catch (...) {
61476       {
61477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61478       };
61479     }
61480   }
61481
61482   jresult = result;
61483   return jresult;
61484 }
61485
61486
61487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61488   float jresult ;
61489   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61490   Dali::Actor *arg2 = 0 ;
61491   Dali::Dimension::Type arg3 ;
61492   SwigDirector_ViewImpl *darg = 0;
61493   float result;
61494
61495   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61496   arg2 = (Dali::Actor *)jarg2;
61497   if (!arg2) {
61498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61499     return 0;
61500   }
61501   arg3 = (Dali::Dimension::Type)jarg3;
61502   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61503   if (!darg) {
61504     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61505     return 0;
61506   }
61507   {
61508     try {
61509       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61510     } catch (std::out_of_range& e) {
61511       {
61512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61513       };
61514     } catch (std::exception& e) {
61515       {
61516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61517       };
61518     } catch (Dali::DaliException e) {
61519       {
61520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61521       };
61522     } catch (...) {
61523       {
61524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61525       };
61526     }
61527   }
61528
61529   jresult = result;
61530   return jresult;
61531 }
61532
61533
61534 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61535   float jresult ;
61536   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61537   float arg2 ;
61538   SwigDirector_ViewImpl *darg = 0;
61539   float result;
61540
61541   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61542   arg2 = (float)jarg2;
61543   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61544   if (!darg) {
61545     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61546     return 0;
61547   }
61548   {
61549     try {
61550       result = (float)(darg)->GetHeightForWidth(arg2);
61551     } catch (std::out_of_range& e) {
61552       {
61553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61554       };
61555     } catch (std::exception& e) {
61556       {
61557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61558       };
61559     } catch (Dali::DaliException e) {
61560       {
61561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61562       };
61563     } catch (...) {
61564       {
61565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61566       };
61567     }
61568   }
61569
61570   jresult = result;
61571   return jresult;
61572 }
61573
61574
61575 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61576   float jresult ;
61577   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61578   float arg2 ;
61579   SwigDirector_ViewImpl *darg = 0;
61580   float result;
61581
61582   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61583   arg2 = (float)jarg2;
61584   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61585   if (!darg) {
61586     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61587     return 0;
61588   }
61589   {
61590     try {
61591       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61592     } catch (std::out_of_range& e) {
61593       {
61594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61595       };
61596     } catch (std::exception& e) {
61597       {
61598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61599       };
61600     } catch (Dali::DaliException e) {
61601       {
61602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61603       };
61604     } catch (...) {
61605       {
61606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61607       };
61608     }
61609   }
61610
61611   jresult = result;
61612   return jresult;
61613 }
61614
61615
61616 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61617   float jresult ;
61618   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61619   float arg2 ;
61620   SwigDirector_ViewImpl *darg = 0;
61621   float result;
61622
61623   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61624   arg2 = (float)jarg2;
61625   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61626   if (!darg) {
61627     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61628     return 0;
61629   }
61630   {
61631     try {
61632       result = (float)(darg)->GetWidthForHeight(arg2);
61633     } catch (std::out_of_range& e) {
61634       {
61635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61636       };
61637     } catch (std::exception& e) {
61638       {
61639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61640       };
61641     } catch (Dali::DaliException e) {
61642       {
61643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61644       };
61645     } catch (...) {
61646       {
61647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61648       };
61649     }
61650   }
61651
61652   jresult = result;
61653   return jresult;
61654 }
61655
61656
61657 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61658   float jresult ;
61659   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61660   float arg2 ;
61661   SwigDirector_ViewImpl *darg = 0;
61662   float result;
61663
61664   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61665   arg2 = (float)jarg2;
61666   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61667   if (!darg) {
61668     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61669     return 0;
61670   }
61671   {
61672     try {
61673       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61674     } catch (std::out_of_range& e) {
61675       {
61676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61677       };
61678     } catch (std::exception& e) {
61679       {
61680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61681       };
61682     } catch (Dali::DaliException e) {
61683       {
61684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61685       };
61686     } catch (...) {
61687       {
61688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61689       };
61690     }
61691   }
61692
61693   jresult = result;
61694   return jresult;
61695 }
61696
61697
61698 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61699   unsigned int jresult ;
61700   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61701   Dali::Dimension::Type arg2 ;
61702   SwigDirector_ViewImpl *darg = 0;
61703   bool result;
61704
61705   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61706   arg2 = (Dali::Dimension::Type)jarg2;
61707   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61708   if (!darg) {
61709     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61710     return 0;
61711   }
61712   {
61713     try {
61714       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61715     } catch (std::out_of_range& e) {
61716       {
61717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61718       };
61719     } catch (std::exception& e) {
61720       {
61721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61722       };
61723     } catch (Dali::DaliException e) {
61724       {
61725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61726       };
61727     } catch (...) {
61728       {
61729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61730       };
61731     }
61732   }
61733
61734   jresult = result;
61735   return jresult;
61736 }
61737
61738
61739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61740   unsigned int jresult ;
61741   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61742   Dali::Dimension::Type arg2 ;
61743   SwigDirector_ViewImpl *darg = 0;
61744   bool result;
61745
61746   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61747   arg2 = (Dali::Dimension::Type)jarg2;
61748   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61749   if (!darg) {
61750     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61751     return 0;
61752   }
61753   {
61754     try {
61755       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61756     } catch (std::out_of_range& e) {
61757       {
61758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61759       };
61760     } catch (std::exception& e) {
61761       {
61762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61763       };
61764     } catch (Dali::DaliException e) {
61765       {
61766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61767       };
61768     } catch (...) {
61769       {
61770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61771       };
61772     }
61773   }
61774
61775   jresult = result;
61776   return jresult;
61777 }
61778
61779
61780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61781   unsigned int jresult ;
61782   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61783   SwigDirector_ViewImpl *darg = 0;
61784   bool result;
61785
61786   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61787   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61788   if (!darg) {
61789     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61790     return 0;
61791   }
61792   {
61793     try {
61794       result = (bool)(darg)->RelayoutDependentOnChildren();
61795     } catch (std::out_of_range& e) {
61796       {
61797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61798       };
61799     } catch (std::exception& e) {
61800       {
61801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61802       };
61803     } catch (Dali::DaliException e) {
61804       {
61805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61806       };
61807     } catch (...) {
61808       {
61809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61810       };
61811     }
61812   }
61813
61814   jresult = result;
61815   return jresult;
61816 }
61817
61818
61819 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61820   unsigned int jresult ;
61821   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61822   SwigDirector_ViewImpl *darg = 0;
61823   bool result;
61824
61825   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61826   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61827   if (!darg) {
61828     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61829     return 0;
61830   }
61831   {
61832     try {
61833       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61834     } catch (std::out_of_range& e) {
61835       {
61836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61837       };
61838     } catch (std::exception& e) {
61839       {
61840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61841       };
61842     } catch (Dali::DaliException e) {
61843       {
61844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61845       };
61846     } catch (...) {
61847       {
61848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61849       };
61850     }
61851   }
61852
61853   jresult = result;
61854   return jresult;
61855 }
61856
61857
61858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61859   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61860   Dali::Dimension::Type arg2 ;
61861   SwigDirector_ViewImpl *darg = 0;
61862
61863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61864   arg2 = (Dali::Dimension::Type)jarg2;
61865   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61866   if (!darg) {
61867     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61868     return;
61869   }
61870   {
61871     try {
61872       (darg)->OnCalculateRelayoutSize(arg2);
61873     } catch (std::out_of_range& e) {
61874       {
61875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61876       };
61877     } catch (std::exception& e) {
61878       {
61879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61880       };
61881     } catch (Dali::DaliException e) {
61882       {
61883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61884       };
61885     } catch (...) {
61886       {
61887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61888       };
61889     }
61890   }
61891
61892 }
61893
61894
61895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61896   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61897   Dali::Dimension::Type arg2 ;
61898   SwigDirector_ViewImpl *darg = 0;
61899
61900   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61901   arg2 = (Dali::Dimension::Type)jarg2;
61902   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61903   if (!darg) {
61904     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61905     return;
61906   }
61907   {
61908     try {
61909       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61910     } catch (std::out_of_range& e) {
61911       {
61912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61913       };
61914     } catch (std::exception& e) {
61915       {
61916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61917       };
61918     } catch (Dali::DaliException e) {
61919       {
61920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61921       };
61922     } catch (...) {
61923       {
61924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61925       };
61926     }
61927   }
61928
61929 }
61930
61931
61932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61933   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61934   float arg2 ;
61935   Dali::Dimension::Type arg3 ;
61936   SwigDirector_ViewImpl *darg = 0;
61937
61938   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61939   arg2 = (float)jarg2;
61940   arg3 = (Dali::Dimension::Type)jarg3;
61941   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61942   if (!darg) {
61943     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61944     return;
61945   }
61946   {
61947     try {
61948       (darg)->OnLayoutNegotiated(arg2,arg3);
61949     } catch (std::out_of_range& e) {
61950       {
61951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61952       };
61953     } catch (std::exception& e) {
61954       {
61955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61956       };
61957     } catch (Dali::DaliException e) {
61958       {
61959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61960       };
61961     } catch (...) {
61962       {
61963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61964       };
61965     }
61966   }
61967
61968 }
61969
61970
61971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61972   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61973   float arg2 ;
61974   Dali::Dimension::Type arg3 ;
61975   SwigDirector_ViewImpl *darg = 0;
61976
61977   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61978   arg2 = (float)jarg2;
61979   arg3 = (Dali::Dimension::Type)jarg3;
61980   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61981   if (!darg) {
61982     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61983     return;
61984   }
61985   {
61986     try {
61987       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61988     } catch (std::out_of_range& e) {
61989       {
61990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61991       };
61992     } catch (std::exception& e) {
61993       {
61994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61995       };
61996     } catch (Dali::DaliException e) {
61997       {
61998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61999       };
62000     } catch (...) {
62001       {
62002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62003       };
62004     }
62005   }
62006
62007 }
62008
62009
62010 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
62011   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62012
62013   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62014   {
62015     try {
62016       (arg1)->OnInitialize();
62017     } catch (std::out_of_range& e) {
62018       {
62019         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62020       };
62021     } catch (std::exception& e) {
62022       {
62023         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62024       };
62025     } catch (Dali::DaliException e) {
62026       {
62027         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62028       };
62029     } catch (...) {
62030       {
62031         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62032       };
62033     }
62034   }
62035
62036 }
62037
62038
62039 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
62040   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62041
62042   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62043   {
62044     try {
62045       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
62046     } catch (std::out_of_range& e) {
62047       {
62048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62049       };
62050     } catch (std::exception& e) {
62051       {
62052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62053       };
62054     } catch (Dali::DaliException e) {
62055       {
62056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62057       };
62058     } catch (...) {
62059       {
62060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62061       };
62062     }
62063   }
62064
62065 }
62066
62067
62068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
62069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62070   Dali::Toolkit::StyleManager arg2 ;
62071   Dali::StyleChange::Type arg3 ;
62072   Dali::Toolkit::StyleManager *argp2 ;
62073
62074   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62075   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62076   if (!argp2) {
62077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62078     return ;
62079   }
62080   arg2 = *argp2;
62081   arg3 = (Dali::StyleChange::Type)jarg3;
62082   {
62083     try {
62084       (arg1)->OnStyleChange(arg2,arg3);
62085     } catch (std::out_of_range& e) {
62086       {
62087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62088       };
62089     } catch (std::exception& e) {
62090       {
62091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62092       };
62093     } catch (Dali::DaliException e) {
62094       {
62095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62096       };
62097     } catch (...) {
62098       {
62099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62100       };
62101     }
62102   }
62103
62104 }
62105
62106
62107 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
62108   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62109   Dali::Toolkit::StyleManager arg2 ;
62110   Dali::StyleChange::Type arg3 ;
62111   Dali::Toolkit::StyleManager *argp2 ;
62112
62113   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62114   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
62115   if (!argp2) {
62116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
62117     return ;
62118   }
62119   arg2 = *argp2;
62120   arg3 = (Dali::StyleChange::Type)jarg3;
62121   {
62122     try {
62123       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
62124     } catch (std::out_of_range& e) {
62125       {
62126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62127       };
62128     } catch (std::exception& e) {
62129       {
62130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62131       };
62132     } catch (Dali::DaliException e) {
62133       {
62134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62135       };
62136     } catch (...) {
62137       {
62138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62139       };
62140     }
62141   }
62142
62143 }
62144
62145
62146 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
62147   unsigned int jresult ;
62148   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62149   bool result;
62150
62151   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62152   {
62153     try {
62154       result = (bool)(arg1)->OnAccessibilityActivated();
62155     } catch (std::out_of_range& e) {
62156       {
62157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62158       };
62159     } catch (std::exception& e) {
62160       {
62161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62162       };
62163     } catch (Dali::DaliException e) {
62164       {
62165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62166       };
62167     } catch (...) {
62168       {
62169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62170       };
62171     }
62172   }
62173
62174   jresult = result;
62175   return jresult;
62176 }
62177
62178
62179 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
62180   unsigned int jresult ;
62181   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62182   bool result;
62183
62184   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62185   {
62186     try {
62187       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
62188     } catch (std::out_of_range& e) {
62189       {
62190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62191       };
62192     } catch (std::exception& e) {
62193       {
62194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62195       };
62196     } catch (Dali::DaliException e) {
62197       {
62198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62199       };
62200     } catch (...) {
62201       {
62202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62203       };
62204     }
62205   }
62206
62207   jresult = result;
62208   return jresult;
62209 }
62210
62211
62212 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
62213   unsigned int jresult ;
62214   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62215   Dali::PanGesture arg2 ;
62216   Dali::PanGesture *argp2 ;
62217   bool result;
62218
62219   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62220   argp2 = (Dali::PanGesture *)jarg2;
62221   if (!argp2) {
62222     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62223     return 0;
62224   }
62225   arg2 = *argp2;
62226   {
62227     try {
62228       result = (bool)(arg1)->OnAccessibilityPan(arg2);
62229     } catch (std::out_of_range& e) {
62230       {
62231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62232       };
62233     } catch (std::exception& e) {
62234       {
62235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62236       };
62237     } catch (Dali::DaliException e) {
62238       {
62239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62240       };
62241     } catch (...) {
62242       {
62243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62244       };
62245     }
62246   }
62247
62248   jresult = result;
62249   return jresult;
62250 }
62251
62252
62253 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62254   unsigned int jresult ;
62255   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62256   Dali::PanGesture arg2 ;
62257   Dali::PanGesture *argp2 ;
62258   bool result;
62259
62260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62261   argp2 = (Dali::PanGesture *)jarg2;
62262   if (!argp2) {
62263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
62264     return 0;
62265   }
62266   arg2 = *argp2;
62267   {
62268     try {
62269       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62277       };
62278     } catch (Dali::DaliException e) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62281       };
62282     } catch (...) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62285       };
62286     }
62287   }
62288
62289   jresult = result;
62290   return jresult;
62291 }
62292
62293
62294 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
62295   unsigned int jresult ;
62296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62297   Dali::TouchEvent *arg2 = 0 ;
62298   bool result;
62299
62300   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62301   arg2 = (Dali::TouchEvent *)jarg2;
62302   if (!arg2) {
62303     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62304     return 0;
62305   }
62306   {
62307     try {
62308       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62309     } catch (std::out_of_range& e) {
62310       {
62311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62312       };
62313     } catch (std::exception& e) {
62314       {
62315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62316       };
62317     } catch (Dali::DaliException e) {
62318       {
62319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62320       };
62321     } catch (...) {
62322       {
62323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62324       };
62325     }
62326   }
62327
62328   jresult = result;
62329   return jresult;
62330 }
62331
62332
62333 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62334   unsigned int jresult ;
62335   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62336   Dali::TouchEvent *arg2 = 0 ;
62337   bool result;
62338
62339   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62340   arg2 = (Dali::TouchEvent *)jarg2;
62341   if (!arg2) {
62342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
62343     return 0;
62344   }
62345   {
62346     try {
62347       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
62348     } catch (std::out_of_range& e) {
62349       {
62350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62351       };
62352     } catch (std::exception& e) {
62353       {
62354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62355       };
62356     } catch (Dali::DaliException e) {
62357       {
62358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62359       };
62360     } catch (...) {
62361       {
62362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62363       };
62364     }
62365   }
62366
62367   jresult = result;
62368   return jresult;
62369 }
62370
62371
62372 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
62373   unsigned int jresult ;
62374   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62375   bool arg2 ;
62376   bool result;
62377
62378   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62379   arg2 = jarg2 ? true : false;
62380   {
62381     try {
62382       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
62383     } catch (std::out_of_range& e) {
62384       {
62385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62386       };
62387     } catch (std::exception& e) {
62388       {
62389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62390       };
62391     } catch (Dali::DaliException e) {
62392       {
62393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62394       };
62395     } catch (...) {
62396       {
62397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62398       };
62399     }
62400   }
62401
62402   jresult = result;
62403   return jresult;
62404 }
62405
62406
62407 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
62408   unsigned int jresult ;
62409   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62410   bool arg2 ;
62411   bool result;
62412
62413   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62414   arg2 = jarg2 ? true : false;
62415   {
62416     try {
62417       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
62418     } catch (std::out_of_range& e) {
62419       {
62420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62421       };
62422     } catch (std::exception& e) {
62423       {
62424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62425       };
62426     } catch (Dali::DaliException e) {
62427       {
62428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62429       };
62430     } catch (...) {
62431       {
62432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62433       };
62434     }
62435   }
62436
62437   jresult = result;
62438   return jresult;
62439 }
62440
62441
62442 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
62443   unsigned int jresult ;
62444   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62445   bool result;
62446
62447   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62448   {
62449     try {
62450       result = (bool)(arg1)->OnAccessibilityZoom();
62451     } catch (std::out_of_range& e) {
62452       {
62453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62454       };
62455     } catch (std::exception& e) {
62456       {
62457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62458       };
62459     } catch (Dali::DaliException e) {
62460       {
62461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62462       };
62463     } catch (...) {
62464       {
62465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62466       };
62467     }
62468   }
62469
62470   jresult = result;
62471   return jresult;
62472 }
62473
62474
62475 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
62476   unsigned int jresult ;
62477   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62478   bool result;
62479
62480   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62481   {
62482     try {
62483       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
62484     } catch (std::out_of_range& e) {
62485       {
62486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62487       };
62488     } catch (std::exception& e) {
62489       {
62490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62491       };
62492     } catch (Dali::DaliException e) {
62493       {
62494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62495       };
62496     } catch (...) {
62497       {
62498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62499       };
62500     }
62501   }
62502
62503   jresult = result;
62504   return jresult;
62505 }
62506
62507
62508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62509   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62510
62511   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62512   {
62513     try {
62514       (arg1)->OnKeyInputFocusGained();
62515     } catch (std::out_of_range& e) {
62516       {
62517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62518       };
62519     } catch (std::exception& e) {
62520       {
62521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62522       };
62523     } catch (Dali::DaliException e) {
62524       {
62525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62526       };
62527     } catch (...) {
62528       {
62529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62530       };
62531     }
62532   }
62533
62534 }
62535
62536
62537 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62538   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62539
62540   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62541   {
62542     try {
62543       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62544     } catch (std::out_of_range& e) {
62545       {
62546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62547       };
62548     } catch (std::exception& e) {
62549       {
62550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62551       };
62552     } catch (Dali::DaliException e) {
62553       {
62554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62555       };
62556     } catch (...) {
62557       {
62558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62559       };
62560     }
62561   }
62562
62563 }
62564
62565
62566 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62567   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62568
62569   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62570   {
62571     try {
62572       (arg1)->OnKeyInputFocusLost();
62573     } catch (std::out_of_range& e) {
62574       {
62575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62576       };
62577     } catch (std::exception& e) {
62578       {
62579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62580       };
62581     } catch (Dali::DaliException e) {
62582       {
62583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62584       };
62585     } catch (...) {
62586       {
62587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62588       };
62589     }
62590   }
62591
62592 }
62593
62594
62595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62596   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62597
62598   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62599   {
62600     try {
62601       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
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_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62625   void * jresult ;
62626   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62627   Dali::Actor arg2 ;
62628   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62629   bool arg4 ;
62630   Dali::Actor *argp2 ;
62631   Dali::Actor result;
62632
62633   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62634   argp2 = (Dali::Actor *)jarg2;
62635   if (!argp2) {
62636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62637     return 0;
62638   }
62639   arg2 = *argp2;
62640   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62641   arg4 = jarg4 ? true : false;
62642   {
62643     try {
62644       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62645     } catch (std::out_of_range& e) {
62646       {
62647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62648       };
62649     } catch (std::exception& e) {
62650       {
62651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62652       };
62653     } catch (Dali::DaliException e) {
62654       {
62655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62656       };
62657     } catch (...) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62660       };
62661     }
62662   }
62663
62664   jresult = new Dali::Actor((const Dali::Actor &)result);
62665   return jresult;
62666 }
62667
62668
62669 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62670   void * jresult ;
62671   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62672   Dali::Actor arg2 ;
62673   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62674   bool arg4 ;
62675   Dali::Actor *argp2 ;
62676   Dali::Actor result;
62677
62678   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62679   argp2 = (Dali::Actor *)jarg2;
62680   if (!argp2) {
62681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62682     return 0;
62683   }
62684   arg2 = *argp2;
62685   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62686   arg4 = jarg4 ? true : false;
62687   {
62688     try {
62689       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62690     } catch (std::out_of_range& e) {
62691       {
62692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62693       };
62694     } catch (std::exception& e) {
62695       {
62696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62697       };
62698     } catch (Dali::DaliException e) {
62699       {
62700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62701       };
62702     } catch (...) {
62703       {
62704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62705       };
62706     }
62707   }
62708
62709   jresult = new Dali::Actor((const Dali::Actor &)result);
62710   return jresult;
62711 }
62712
62713
62714 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62715   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62716   Dali::Actor arg2 ;
62717   Dali::Actor *argp2 ;
62718
62719   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62720   argp2 = (Dali::Actor *)jarg2;
62721   if (!argp2) {
62722     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62723     return ;
62724   }
62725   arg2 = *argp2;
62726   {
62727     try {
62728       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62729     } catch (std::out_of_range& e) {
62730       {
62731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62732       };
62733     } catch (std::exception& e) {
62734       {
62735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62736       };
62737     } catch (Dali::DaliException e) {
62738       {
62739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62740       };
62741     } catch (...) {
62742       {
62743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62744       };
62745     }
62746   }
62747
62748 }
62749
62750
62751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62752   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62753   Dali::Actor arg2 ;
62754   Dali::Actor *argp2 ;
62755
62756   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62757   argp2 = (Dali::Actor *)jarg2;
62758   if (!argp2) {
62759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62760     return ;
62761   }
62762   arg2 = *argp2;
62763   {
62764     try {
62765       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62766     } catch (std::out_of_range& e) {
62767       {
62768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62769       };
62770     } catch (std::exception& e) {
62771       {
62772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62773       };
62774     } catch (Dali::DaliException e) {
62775       {
62776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62777       };
62778     } catch (...) {
62779       {
62780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62781       };
62782     }
62783   }
62784
62785 }
62786
62787
62788 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62789   unsigned int jresult ;
62790   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62791   bool result;
62792
62793   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62794   {
62795     try {
62796       result = (bool)(arg1)->OnKeyboardEnter();
62797     } catch (std::out_of_range& e) {
62798       {
62799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62800       };
62801     } catch (std::exception& e) {
62802       {
62803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62804       };
62805     } catch (Dali::DaliException e) {
62806       {
62807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62808       };
62809     } catch (...) {
62810       {
62811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62812       };
62813     }
62814   }
62815
62816   jresult = result;
62817   return jresult;
62818 }
62819
62820
62821 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62822   unsigned int jresult ;
62823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62824   bool result;
62825
62826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62827   {
62828     try {
62829       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62830     } catch (std::out_of_range& e) {
62831       {
62832         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62833       };
62834     } catch (std::exception& e) {
62835       {
62836         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62837       };
62838     } catch (Dali::DaliException e) {
62839       {
62840         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62841       };
62842     } catch (...) {
62843       {
62844         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62845       };
62846     }
62847   }
62848
62849   jresult = result;
62850   return jresult;
62851 }
62852
62853
62854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62855   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62856   Dali::PinchGesture *arg2 = 0 ;
62857
62858   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62859   arg2 = (Dali::PinchGesture *)jarg2;
62860   if (!arg2) {
62861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62862     return ;
62863   }
62864   {
62865     try {
62866       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62867     } catch (std::out_of_range& e) {
62868       {
62869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62870       };
62871     } catch (std::exception& e) {
62872       {
62873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62874       };
62875     } catch (Dali::DaliException e) {
62876       {
62877         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62878       };
62879     } catch (...) {
62880       {
62881         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62882       };
62883     }
62884   }
62885
62886 }
62887
62888
62889 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62890   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62891   Dali::PinchGesture *arg2 = 0 ;
62892
62893   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62894   arg2 = (Dali::PinchGesture *)jarg2;
62895   if (!arg2) {
62896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62897     return ;
62898   }
62899   {
62900     try {
62901       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62902     } catch (std::out_of_range& e) {
62903       {
62904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62905       };
62906     } catch (std::exception& e) {
62907       {
62908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62909       };
62910     } catch (Dali::DaliException e) {
62911       {
62912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62913       };
62914     } catch (...) {
62915       {
62916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62917       };
62918     }
62919   }
62920
62921 }
62922
62923
62924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62925   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62926   Dali::PanGesture *arg2 = 0 ;
62927
62928   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62929   arg2 = (Dali::PanGesture *)jarg2;
62930   if (!arg2) {
62931     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62932     return ;
62933   }
62934   {
62935     try {
62936       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62937     } catch (std::out_of_range& e) {
62938       {
62939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62940       };
62941     } catch (std::exception& e) {
62942       {
62943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62944       };
62945     } catch (Dali::DaliException e) {
62946       {
62947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62948       };
62949     } catch (...) {
62950       {
62951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62952       };
62953     }
62954   }
62955
62956 }
62957
62958
62959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62960   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62961   Dali::PanGesture *arg2 = 0 ;
62962
62963   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62964   arg2 = (Dali::PanGesture *)jarg2;
62965   if (!arg2) {
62966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62967     return ;
62968   }
62969   {
62970     try {
62971       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62972     } catch (std::out_of_range& e) {
62973       {
62974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62975       };
62976     } catch (std::exception& e) {
62977       {
62978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62979       };
62980     } catch (Dali::DaliException e) {
62981       {
62982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62983       };
62984     } catch (...) {
62985       {
62986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62987       };
62988     }
62989   }
62990
62991 }
62992
62993
62994 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62995   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62996   Dali::TapGesture *arg2 = 0 ;
62997
62998   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62999   arg2 = (Dali::TapGesture *)jarg2;
63000   if (!arg2) {
63001     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63002     return ;
63003   }
63004   {
63005     try {
63006       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
63007     } catch (std::out_of_range& e) {
63008       {
63009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63010       };
63011     } catch (std::exception& e) {
63012       {
63013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63014       };
63015     } catch (Dali::DaliException e) {
63016       {
63017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63018       };
63019     } catch (...) {
63020       {
63021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63022       };
63023     }
63024   }
63025
63026 }
63027
63028
63029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63030   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63031   Dali::TapGesture *arg2 = 0 ;
63032
63033   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63034   arg2 = (Dali::TapGesture *)jarg2;
63035   if (!arg2) {
63036     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
63037     return ;
63038   }
63039   {
63040     try {
63041       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
63042     } catch (std::out_of_range& e) {
63043       {
63044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63045       };
63046     } catch (std::exception& e) {
63047       {
63048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63049       };
63050     } catch (Dali::DaliException e) {
63051       {
63052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63053       };
63054     } catch (...) {
63055       {
63056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63057       };
63058     }
63059   }
63060
63061 }
63062
63063
63064 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
63065   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63066   Dali::LongPressGesture *arg2 = 0 ;
63067
63068   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63069   arg2 = (Dali::LongPressGesture *)jarg2;
63070   if (!arg2) {
63071     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63072     return ;
63073   }
63074   {
63075     try {
63076       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
63077     } catch (std::out_of_range& e) {
63078       {
63079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63080       };
63081     } catch (std::exception& e) {
63082       {
63083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63084       };
63085     } catch (Dali::DaliException e) {
63086       {
63087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63088       };
63089     } catch (...) {
63090       {
63091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63092       };
63093     }
63094   }
63095
63096 }
63097
63098
63099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
63100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63101   Dali::LongPressGesture *arg2 = 0 ;
63102
63103   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63104   arg2 = (Dali::LongPressGesture *)jarg2;
63105   if (!arg2) {
63106     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
63107     return ;
63108   }
63109   {
63110     try {
63111       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
63112     } catch (std::out_of_range& e) {
63113       {
63114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63115       };
63116     } catch (std::exception& e) {
63117       {
63118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63119       };
63120     } catch (Dali::DaliException e) {
63121       {
63122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63123       };
63124     } catch (...) {
63125       {
63126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63127       };
63128     }
63129   }
63130
63131 }
63132
63133
63134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
63135   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63136   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63137   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63138
63139   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63140   arg2 = (Dali::SlotObserver *)jarg2;
63141   arg3 = (Dali::CallbackBase *)jarg3;
63142   {
63143     try {
63144       (arg1)->SignalConnected(arg2,arg3);
63145     } catch (std::out_of_range& e) {
63146       {
63147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63148       };
63149     } catch (std::exception& e) {
63150       {
63151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63152       };
63153     } catch (Dali::DaliException e) {
63154       {
63155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63156       };
63157     } catch (...) {
63158       {
63159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63160       };
63161     }
63162   }
63163
63164 }
63165
63166
63167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63168   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63169   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63170   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63171
63172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63173   arg2 = (Dali::SlotObserver *)jarg2;
63174   arg3 = (Dali::CallbackBase *)jarg3;
63175   {
63176     try {
63177       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
63178     } catch (std::out_of_range& e) {
63179       {
63180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63181       };
63182     } catch (std::exception& e) {
63183       {
63184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63185       };
63186     } catch (Dali::DaliException e) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63189       };
63190     } catch (...) {
63191       {
63192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63193       };
63194     }
63195   }
63196
63197 }
63198
63199
63200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
63201   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63202   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63203   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63204
63205   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63206   arg2 = (Dali::SlotObserver *)jarg2;
63207   arg3 = (Dali::CallbackBase *)jarg3;
63208   {
63209     try {
63210       (arg1)->SignalDisconnected(arg2,arg3);
63211     } catch (std::out_of_range& e) {
63212       {
63213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63214       };
63215     } catch (std::exception& e) {
63216       {
63217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63218       };
63219     } catch (Dali::DaliException e) {
63220       {
63221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63222       };
63223     } catch (...) {
63224       {
63225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63226       };
63227     }
63228   }
63229
63230 }
63231
63232
63233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
63234   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
63235   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
63236   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
63237
63238   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63239   arg2 = (Dali::SlotObserver *)jarg2;
63240   arg3 = (Dali::CallbackBase *)jarg3;
63241   {
63242     try {
63243       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
63244     } catch (std::out_of_range& e) {
63245       {
63246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63247       };
63248     } catch (std::exception& e) {
63249       {
63250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63251       };
63252     } catch (Dali::DaliException e) {
63253       {
63254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63255       };
63256     } catch (...) {
63257       {
63258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63259       };
63260     }
63261   }
63262
63263 }
63264
63265
63266 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_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) {
63267   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
63268   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
63269   if (director) {
63270     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, callback24, callback25, callback26, callback27, callback28, callback29, callback30, callback31, callback32, callback33, callback34, callback35, callback36, callback37, callback38, callback39, callback40);
63271   }
63272 }
63273
63274
63275 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
63276   void * jresult ;
63277   Dali::Toolkit::Control *arg1 = 0 ;
63278   Dali::Toolkit::Internal::Control *result = 0 ;
63279
63280   arg1 = (Dali::Toolkit::Control *)jarg1;
63281   if (!arg1) {
63282     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63283     return 0;
63284   }
63285   {
63286     try {
63287       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
63288     } catch (std::out_of_range& e) {
63289       {
63290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63291       };
63292     } catch (std::exception& e) {
63293       {
63294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63295       };
63296     } catch (Dali::DaliException e) {
63297       {
63298         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63299       };
63300     } catch (...) {
63301       {
63302         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63303       };
63304     }
63305   }
63306
63307   jresult = (void *)result;
63308   return jresult;
63309 }
63310
63311
63312 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
63313   int jresult ;
63314   int result;
63315
63316   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
63317   jresult = (int)result;
63318   return jresult;
63319 }
63320
63321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
63322   int jresult ;
63323   int result;
63324
63325   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
63326   jresult = (int)result;
63327   return jresult;
63328 }
63329
63330
63331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
63332   int jresult ;
63333   int result;
63334
63335   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
63336   jresult = (int)result;
63337   return jresult;
63338 }
63339
63340 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
63341   int jresult ;
63342   int result;
63343
63344   result = (int)Dali::Toolkit::Control::Property::MARGIN;
63345   jresult = (int)result;
63346   return jresult;
63347 }
63348
63349
63350 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
63351   int jresult ;
63352   int result;
63353
63354   result = (int)Dali::Toolkit::Control::Property::PADDING;
63355   jresult = (int)result;
63356   return jresult;
63357 }
63358
63359 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
63360   int jresult ;
63361   int result;
63362
63363   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
63364   jresult = (int)result;
63365   return jresult;
63366 }
63367
63368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
63369   void * jresult ;
63370   Dali::Toolkit::Control::Property *result = 0 ;
63371
63372   {
63373     try {
63374       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
63375     } catch (std::out_of_range& e) {
63376       {
63377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63378       };
63379     } catch (std::exception& e) {
63380       {
63381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63382       };
63383     } catch (Dali::DaliException e) {
63384       {
63385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63386       };
63387     } catch (...) {
63388       {
63389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63390       };
63391     }
63392   }
63393
63394   jresult = (void *)result;
63395   return jresult;
63396 }
63397
63398
63399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
63400   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
63401
63402   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
63403   {
63404     try {
63405       delete arg1;
63406     } catch (std::out_of_range& e) {
63407       {
63408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63409       };
63410     } catch (std::exception& e) {
63411       {
63412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63413       };
63414     } catch (Dali::DaliException e) {
63415       {
63416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63417       };
63418     } catch (...) {
63419       {
63420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63421       };
63422     }
63423   }
63424
63425 }
63426
63427
63428 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
63429   void * jresult ;
63430   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
63431
63432   {
63433     try {
63434       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63442       };
63443     } catch (Dali::DaliException e) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63450       };
63451     }
63452   }
63453
63454   jresult = (void *)result;
63455   return jresult;
63456 }
63457
63458
63459 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
63460   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
63461
63462   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
63463   {
63464     try {
63465       delete arg1;
63466     } catch (std::out_of_range& e) {
63467       {
63468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63469       };
63470     } catch (std::exception& e) {
63471       {
63472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63473       };
63474     } catch (Dali::DaliException e) {
63475       {
63476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63477       };
63478     } catch (...) {
63479       {
63480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63481       };
63482     }
63483   }
63484
63485 }
63486
63487
63488 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
63489   void * jresult ;
63490   Dali::Toolkit::Control result;
63491
63492   {
63493     try {
63494       result = Dali::Toolkit::Control::New();
63495     } catch (std::out_of_range& e) {
63496       {
63497         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63498       };
63499     } catch (std::exception& e) {
63500       {
63501         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63502       };
63503     } catch (Dali::DaliException e) {
63504       {
63505         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63506       };
63507     } catch (...) {
63508       {
63509         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63510       };
63511     }
63512   }
63513
63514   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63515   return jresult;
63516 }
63517
63518
63519 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63520   void * jresult ;
63521   Dali::Toolkit::Control *result = 0 ;
63522
63523   {
63524     try {
63525       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63526     } catch (std::out_of_range& e) {
63527       {
63528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63529       };
63530     } catch (std::exception& e) {
63531       {
63532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63533       };
63534     } catch (Dali::DaliException e) {
63535       {
63536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63537       };
63538     } catch (...) {
63539       {
63540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63541       };
63542     }
63543   }
63544
63545   jresult = (void *)result;
63546   return jresult;
63547 }
63548
63549
63550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63551   void * jresult ;
63552   Dali::Toolkit::Control *arg1 = 0 ;
63553   Dali::Toolkit::Control *result = 0 ;
63554
63555   arg1 = (Dali::Toolkit::Control *)jarg1;
63556   if (!arg1) {
63557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63558     return 0;
63559   }
63560   {
63561     try {
63562       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63563     } catch (std::out_of_range& e) {
63564       {
63565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63566       };
63567     } catch (std::exception& e) {
63568       {
63569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63570       };
63571     } catch (Dali::DaliException e) {
63572       {
63573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63574       };
63575     } catch (...) {
63576       {
63577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63578       };
63579     }
63580   }
63581
63582   jresult = (void *)result;
63583   return jresult;
63584 }
63585
63586
63587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63588   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63589
63590   arg1 = (Dali::Toolkit::Control *)jarg1;
63591   {
63592     try {
63593       delete arg1;
63594     } catch (std::out_of_range& e) {
63595       {
63596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63597       };
63598     } catch (std::exception& e) {
63599       {
63600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63601       };
63602     } catch (Dali::DaliException e) {
63603       {
63604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63605       };
63606     } catch (...) {
63607       {
63608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63609       };
63610     }
63611   }
63612
63613 }
63614
63615
63616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63617   void * jresult ;
63618   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63619   Dali::Toolkit::Control *arg2 = 0 ;
63620   Dali::Toolkit::Control *result = 0 ;
63621
63622   arg1 = (Dali::Toolkit::Control *)jarg1;
63623   arg2 = (Dali::Toolkit::Control *)jarg2;
63624   if (!arg2) {
63625     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63626     return 0;
63627   }
63628   {
63629     try {
63630       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63631     } catch (std::out_of_range& e) {
63632       {
63633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63634       };
63635     } catch (std::exception& e) {
63636       {
63637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63638       };
63639     } catch (Dali::DaliException e) {
63640       {
63641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63642       };
63643     } catch (...) {
63644       {
63645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63646       };
63647     }
63648   }
63649
63650   jresult = (void *)result;
63651   return jresult;
63652 }
63653
63654
63655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63656   void * jresult ;
63657   Dali::BaseHandle arg1 ;
63658   Dali::BaseHandle *argp1 ;
63659   Dali::Toolkit::Control result;
63660
63661   argp1 = (Dali::BaseHandle *)jarg1;
63662   if (!argp1) {
63663     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63664     return 0;
63665   }
63666   arg1 = *argp1;
63667   {
63668     try {
63669       result = Dali::Toolkit::Control::DownCast(arg1);
63670     } catch (std::out_of_range& e) {
63671       {
63672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63673       };
63674     } catch (std::exception& e) {
63675       {
63676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63677       };
63678     } catch (Dali::DaliException e) {
63679       {
63680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63681       };
63682     } catch (...) {
63683       {
63684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63685       };
63686     }
63687   }
63688
63689   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63690   return jresult;
63691 }
63692
63693
63694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63695   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63696
63697   arg1 = (Dali::Toolkit::Control *)jarg1;
63698   {
63699     try {
63700       (arg1)->SetKeyInputFocus();
63701     } catch (std::out_of_range& e) {
63702       {
63703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63704       };
63705     } catch (std::exception& e) {
63706       {
63707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63708       };
63709     } catch (Dali::DaliException e) {
63710       {
63711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63712       };
63713     } catch (...) {
63714       {
63715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63716       };
63717     }
63718   }
63719
63720 }
63721
63722
63723 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63724   unsigned int jresult ;
63725   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63726   bool result;
63727
63728   arg1 = (Dali::Toolkit::Control *)jarg1;
63729   {
63730     try {
63731       result = (bool)(arg1)->HasKeyInputFocus();
63732     } catch (std::out_of_range& e) {
63733       {
63734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63735       };
63736     } catch (std::exception& e) {
63737       {
63738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63739       };
63740     } catch (Dali::DaliException e) {
63741       {
63742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63743       };
63744     } catch (...) {
63745       {
63746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63747       };
63748     }
63749   }
63750
63751   jresult = result;
63752   return jresult;
63753 }
63754
63755
63756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63757   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63758
63759   arg1 = (Dali::Toolkit::Control *)jarg1;
63760   {
63761     try {
63762       (arg1)->ClearKeyInputFocus();
63763     } catch (std::out_of_range& e) {
63764       {
63765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63766       };
63767     } catch (std::exception& e) {
63768       {
63769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63770       };
63771     } catch (Dali::DaliException e) {
63772       {
63773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63774       };
63775     } catch (...) {
63776       {
63777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63778       };
63779     }
63780   }
63781
63782 }
63783
63784
63785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63786   void * jresult ;
63787   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63788   Dali::PinchGestureDetector result;
63789
63790   arg1 = (Dali::Toolkit::Control *)jarg1;
63791   {
63792     try {
63793       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63794     } catch (std::out_of_range& e) {
63795       {
63796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63797       };
63798     } catch (std::exception& e) {
63799       {
63800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63801       };
63802     } catch (Dali::DaliException e) {
63803       {
63804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63805       };
63806     } catch (...) {
63807       {
63808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63809       };
63810     }
63811   }
63812
63813   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63814   return jresult;
63815 }
63816
63817
63818 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63819   void * jresult ;
63820   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63821   Dali::PanGestureDetector result;
63822
63823   arg1 = (Dali::Toolkit::Control *)jarg1;
63824   {
63825     try {
63826       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63827     } catch (std::out_of_range& e) {
63828       {
63829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63830       };
63831     } catch (std::exception& e) {
63832       {
63833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63834       };
63835     } catch (Dali::DaliException e) {
63836       {
63837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63838       };
63839     } catch (...) {
63840       {
63841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63842       };
63843     }
63844   }
63845
63846   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63847   return jresult;
63848 }
63849
63850
63851 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63852   void * jresult ;
63853   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63854   Dali::TapGestureDetector result;
63855
63856   arg1 = (Dali::Toolkit::Control *)jarg1;
63857   {
63858     try {
63859       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63860     } catch (std::out_of_range& e) {
63861       {
63862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63863       };
63864     } catch (std::exception& e) {
63865       {
63866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63867       };
63868     } catch (Dali::DaliException e) {
63869       {
63870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63871       };
63872     } catch (...) {
63873       {
63874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63875       };
63876     }
63877   }
63878
63879   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63880   return jresult;
63881 }
63882
63883
63884 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63885   void * jresult ;
63886   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63887   Dali::LongPressGestureDetector result;
63888
63889   arg1 = (Dali::Toolkit::Control *)jarg1;
63890   {
63891     try {
63892       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63893     } catch (std::out_of_range& e) {
63894       {
63895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63896       };
63897     } catch (std::exception& e) {
63898       {
63899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63900       };
63901     } catch (Dali::DaliException e) {
63902       {
63903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63904       };
63905     } catch (...) {
63906       {
63907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63908       };
63909     }
63910   }
63911
63912   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63913   return jresult;
63914 }
63915
63916
63917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63918   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63919   std::string *arg2 = 0 ;
63920
63921   arg1 = (Dali::Toolkit::Control *)jarg1;
63922   if (!jarg2) {
63923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63924     return ;
63925   }
63926   std::string arg2_str(jarg2);
63927   arg2 = &arg2_str;
63928   {
63929     try {
63930       (arg1)->SetStyleName((std::string const &)*arg2);
63931     } catch (std::out_of_range& e) {
63932       {
63933         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63934       };
63935     } catch (std::exception& e) {
63936       {
63937         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63938       };
63939     } catch (Dali::DaliException e) {
63940       {
63941         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63942       };
63943     } catch (...) {
63944       {
63945         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63946       };
63947     }
63948   }
63949
63950
63951   //argout typemap for const std::string&
63952
63953 }
63954
63955
63956 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63957   char * jresult ;
63958   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63959   std::string *result = 0 ;
63960
63961   arg1 = (Dali::Toolkit::Control *)jarg1;
63962   {
63963     try {
63964       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63965     } catch (std::out_of_range& e) {
63966       {
63967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63968       };
63969     } catch (std::exception& e) {
63970       {
63971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63972       };
63973     } catch (Dali::DaliException e) {
63974       {
63975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63976       };
63977     } catch (...) {
63978       {
63979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63980       };
63981     }
63982   }
63983
63984   jresult = SWIG_csharp_string_callback(result->c_str());
63985   return jresult;
63986 }
63987
63988
63989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63990   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63991   Dali::Vector4 *arg2 = 0 ;
63992
63993   arg1 = (Dali::Toolkit::Control *)jarg1;
63994   arg2 = (Dali::Vector4 *)jarg2;
63995   if (!arg2) {
63996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63997     return ;
63998   }
63999   {
64000     try {
64001       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
64002     } catch (std::out_of_range& e) {
64003       {
64004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64005       };
64006     } catch (std::exception& e) {
64007       {
64008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64009       };
64010     } catch (Dali::DaliException e) {
64011       {
64012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64013       };
64014     } catch (...) {
64015       {
64016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64017       };
64018     }
64019   }
64020
64021 }
64022
64023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
64024   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64025
64026   arg1 = (Dali::Toolkit::Control *)jarg1;
64027   {
64028     try {
64029       (arg1)->ClearBackground();
64030     } catch (std::out_of_range& e) {
64031       {
64032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64033       };
64034     } catch (std::exception& e) {
64035       {
64036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64037       };
64038     } catch (Dali::DaliException e) {
64039       {
64040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64041       };
64042     } catch (...) {
64043       {
64044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64045       };
64046     }
64047   }
64048
64049 }
64050
64051
64052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
64053   void * jresult ;
64054   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64055   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
64056
64057   arg1 = (Dali::Toolkit::Control *)jarg1;
64058   {
64059     try {
64060       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
64061     } catch (std::out_of_range& e) {
64062       {
64063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64064       };
64065     } catch (std::exception& e) {
64066       {
64067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64068       };
64069     } catch (Dali::DaliException e) {
64070       {
64071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64072       };
64073     } catch (...) {
64074       {
64075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64076       };
64077     }
64078   }
64079
64080   jresult = (void *)result;
64081   return jresult;
64082 }
64083
64084
64085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
64086   void * jresult ;
64087   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64088   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64089
64090   arg1 = (Dali::Toolkit::Control *)jarg1;
64091   {
64092     try {
64093       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
64094     } catch (std::out_of_range& e) {
64095       {
64096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64097       };
64098     } catch (std::exception& e) {
64099       {
64100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64101       };
64102     } catch (Dali::DaliException e) {
64103       {
64104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64105       };
64106     } catch (...) {
64107       {
64108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64109       };
64110     }
64111   }
64112
64113   jresult = (void *)result;
64114   return jresult;
64115 }
64116
64117
64118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
64119   void * jresult ;
64120   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64121   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
64122
64123   arg1 = (Dali::Toolkit::Control *)jarg1;
64124   {
64125     try {
64126       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
64127     } catch (std::out_of_range& e) {
64128       {
64129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64130       };
64131     } catch (std::exception& e) {
64132       {
64133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64134       };
64135     } catch (Dali::DaliException e) {
64136       {
64137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64138       };
64139     } catch (...) {
64140       {
64141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64142       };
64143     }
64144   }
64145
64146   jresult = (void *)result;
64147   return jresult;
64148 }
64149
64150
64151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_2(void * jarg1) {
64152   void * jresult ;
64153   Dali::Toolkit::Internal::Control *arg1 = 0 ;
64154   Dali::Toolkit::Control *result = 0 ;
64155
64156   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
64157   if (!arg1) {
64158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
64159     return 0;
64160   }
64161   {
64162     try {
64163       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
64164     } catch (std::out_of_range& e) {
64165       {
64166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64167       };
64168     } catch (std::exception& e) {
64169       {
64170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64171       };
64172     } catch (Dali::DaliException e) {
64173       {
64174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64175       };
64176     } catch (...) {
64177       {
64178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64179       };
64180     }
64181   }
64182
64183   jresult = (void *)result;
64184   return jresult;
64185 }
64186
64187 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
64188 {
64189   int jresult;
64190   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64191   arg1 = (Dali::Toolkit::Control *)jarg1;
64192
64193   if (!arg1) {
64194     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64195     return 0;
64196   }
64197
64198   Dali::Property::Index arg2 = 0 ;
64199   arg2 = (Dali::Property::Index)jarg2;
64200
64201   Toolkit::Visual::ResourceStatus result;
64202   {
64203     try {
64204       result = arg1->GetVisualResourceStatus(arg2);
64205     } catch (std::out_of_range& e) {
64206       {
64207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64208       };
64209     } catch (std::exception& e) {
64210       {
64211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64212       };
64213     } catch (...) {
64214       {
64215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64216       };
64217     }
64218   }
64219   jresult = (int)(result);
64220   return jresult;
64221 }
64222
64223 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
64224 {
64225   void * jresult;
64226   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
64227   arg1 = (Dali::Toolkit::Control *)jarg1;
64228
64229   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
64230
64231   Dali::Toolkit::TransitionData *arg2 = 0 ;
64232   Dali::Animation result;
64233
64234   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
64235   if (!arg2) {
64236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
64237     return 0;
64238   }
64239   {
64240     try {
64241       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
64242     } catch (std::out_of_range& e) {
64243       {
64244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64245       };
64246     } catch (std::exception& e) {
64247       {
64248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64249       };
64250     } catch (Dali::DaliException e) {
64251       {
64252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64253       };
64254     } catch (...) {
64255       {
64256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64257       };
64258     }
64259   }
64260
64261   jresult = new Dali::Animation((const Dali::Animation &)result);
64262   return jresult;
64263 }
64264
64265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
64266 {
64267   Dali::Toolkit::Control arg1;
64268   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
64269
64270   if (!argp1) {
64271     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64272   }
64273   arg1 = *argp1;
64274
64275   Dali::Property::Index arg2 = 0 ;
64276   arg2 = (Dali::Property::Index)jarg2;
64277
64278   Dali::Property::Index arg3 = 0 ;
64279   arg3 = (Dali::Property::Index)jarg3;
64280
64281   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
64282
64283   {
64284     try {
64285       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
64286     } catch (std::out_of_range& e) {
64287       {
64288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64289       };
64290     } catch (std::exception& e) {
64291       {
64292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64293       };
64294     } catch (...) {
64295       {
64296         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64297       };
64298     }
64299   }
64300
64301
64302 }
64303
64304 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
64305   void * jresult ;
64306   Dali::Toolkit::Control *arg1 = 0 ;
64307   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
64308
64309   arg1 = (Dali::Toolkit::Control *)jarg1;
64310   if (!arg1) {
64311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
64312     return 0;
64313   }
64314   {
64315     try {
64316       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
64317     } catch (std::out_of_range& e) {
64318       {
64319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64320       };
64321     } catch (std::exception& e) {
64322       {
64323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64324       };
64325     } catch (Dali::DaliException e) {
64326       {
64327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64328       };
64329     } catch (...) {
64330       {
64331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64332       };
64333     }
64334   }
64335
64336   jresult = (void *)result;
64337   return jresult;
64338 }
64339
64340
64341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
64342   unsigned int jresult ;
64343   Dali::Toolkit::Control *arg1 = 0 ;
64344   bool result;
64345
64346   arg1 = (Dali::Toolkit::Control *)jarg1;
64347   if (!arg1) {
64348     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
64349     return 0;
64350   }
64351   {
64352     try {
64353       result = (bool)arg1->IsResourceReady();
64354     } catch (std::out_of_range& e) {
64355       {
64356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64357       };
64358     } catch (std::exception& e) {
64359       {
64360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64361       };
64362     } catch (Dali::DaliException e) {
64363       {
64364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64365       };
64366     } catch (...) {
64367       {
64368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64369       };
64370     }
64371   }
64372
64373   jresult = result;
64374   return jresult;
64375 }
64376
64377
64378 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
64379   void * jresult ;
64380   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
64381
64382   {
64383     try {
64384       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
64385     } catch (std::out_of_range& e) {
64386       {
64387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64388       };
64389     } catch (std::exception& e) {
64390       {
64391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64392       };
64393     } catch (Dali::DaliException e) {
64394       {
64395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64396       };
64397     } catch (...) {
64398       {
64399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64400       };
64401     }
64402   }
64403
64404   jresult = (void *)result;
64405   return jresult;
64406 }
64407
64408
64409 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
64410   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64411
64412   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64413   {
64414     try {
64415       delete arg1;
64416     } catch (std::out_of_range& e) {
64417       {
64418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64419       };
64420     } catch (std::exception& e) {
64421       {
64422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64423       };
64424     } catch (Dali::DaliException e) {
64425       {
64426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64427       };
64428     } catch (...) {
64429       {
64430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64431       };
64432     }
64433   }
64434
64435 }
64436
64437
64438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
64439   void * jresult ;
64440   Dali::Toolkit::KeyInputFocusManager result;
64441
64442   {
64443     try {
64444       result = Dali::Toolkit::KeyInputFocusManager::Get();
64445     } catch (std::out_of_range& e) {
64446       {
64447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64448       };
64449     } catch (std::exception& e) {
64450       {
64451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64452       };
64453     } catch (Dali::DaliException e) {
64454       {
64455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64456       };
64457     } catch (...) {
64458       {
64459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64460       };
64461     }
64462   }
64463
64464   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
64465   return jresult;
64466 }
64467
64468
64469 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
64470   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64471   Dali::Toolkit::Control arg2 ;
64472   Dali::Toolkit::Control *argp2 ;
64473
64474   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64475   argp2 = (Dali::Toolkit::Control *)jarg2;
64476   if (!argp2) {
64477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64478     return ;
64479   }
64480   arg2 = *argp2;
64481   {
64482     try {
64483       (arg1)->SetFocus(arg2);
64484     } catch (std::out_of_range& e) {
64485       {
64486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64487       };
64488     } catch (std::exception& e) {
64489       {
64490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64491       };
64492     } catch (Dali::DaliException e) {
64493       {
64494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64495       };
64496     } catch (...) {
64497       {
64498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64499       };
64500     }
64501   }
64502
64503 }
64504
64505
64506 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64507   void * jresult ;
64508   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64509   Dali::Toolkit::Control result;
64510
64511   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64512   {
64513     try {
64514       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64515     } catch (std::out_of_range& e) {
64516       {
64517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64518       };
64519     } catch (std::exception& e) {
64520       {
64521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64522       };
64523     } catch (Dali::DaliException e) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64526       };
64527     } catch (...) {
64528       {
64529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64530       };
64531     }
64532   }
64533
64534   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64535   return jresult;
64536 }
64537
64538
64539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64540   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64541   Dali::Toolkit::Control arg2 ;
64542   Dali::Toolkit::Control *argp2 ;
64543
64544   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64545   argp2 = (Dali::Toolkit::Control *)jarg2;
64546   if (!argp2) {
64547     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64548     return ;
64549   }
64550   arg2 = *argp2;
64551   {
64552     try {
64553       (arg1)->RemoveFocus(arg2);
64554     } catch (std::out_of_range& e) {
64555       {
64556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64557       };
64558     } catch (std::exception& e) {
64559       {
64560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64561       };
64562     } catch (Dali::DaliException e) {
64563       {
64564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64565       };
64566     } catch (...) {
64567       {
64568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64569       };
64570     }
64571   }
64572
64573 }
64574
64575
64576 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64577   void * jresult ;
64578   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64579   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64580
64581   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64582   {
64583     try {
64584       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64585     } catch (std::out_of_range& e) {
64586       {
64587         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64588       };
64589     } catch (std::exception& e) {
64590       {
64591         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64592       };
64593     } catch (Dali::DaliException e) {
64594       {
64595         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64596       };
64597     } catch (...) {
64598       {
64599         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64600       };
64601     }
64602   }
64603
64604   jresult = (void *)result;
64605   return jresult;
64606 }
64607
64608
64609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64610   void * jresult ;
64611   Dali::Toolkit::Alignment::Padding *result = 0 ;
64612
64613   {
64614     try {
64615       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64616     } catch (std::out_of_range& e) {
64617       {
64618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64619       };
64620     } catch (std::exception& e) {
64621       {
64622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64623       };
64624     } catch (Dali::DaliException e) {
64625       {
64626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64627       };
64628     } catch (...) {
64629       {
64630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64631       };
64632     }
64633   }
64634
64635   jresult = (void *)result;
64636   return jresult;
64637 }
64638
64639
64640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64641   void * jresult ;
64642   float arg1 ;
64643   float arg2 ;
64644   float arg3 ;
64645   float arg4 ;
64646   Dali::Toolkit::Alignment::Padding *result = 0 ;
64647
64648   arg1 = (float)jarg1;
64649   arg2 = (float)jarg2;
64650   arg3 = (float)jarg3;
64651   arg4 = (float)jarg4;
64652   {
64653     try {
64654       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64655     } catch (std::out_of_range& e) {
64656       {
64657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64658       };
64659     } catch (std::exception& e) {
64660       {
64661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64662       };
64663     } catch (Dali::DaliException e) {
64664       {
64665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64666       };
64667     } catch (...) {
64668       {
64669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64670       };
64671     }
64672   }
64673
64674   jresult = (void *)result;
64675   return jresult;
64676 }
64677
64678
64679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64680   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64681   float arg2 ;
64682
64683   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64684   arg2 = (float)jarg2;
64685   if (arg1) (arg1)->left = arg2;
64686 }
64687
64688
64689 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64690   float jresult ;
64691   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64692   float result;
64693
64694   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64695   result = (float) ((arg1)->left);
64696   jresult = result;
64697   return jresult;
64698 }
64699
64700
64701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64702   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64703   float arg2 ;
64704
64705   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64706   arg2 = (float)jarg2;
64707   if (arg1) (arg1)->right = arg2;
64708 }
64709
64710
64711 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64712   float jresult ;
64713   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64714   float result;
64715
64716   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64717   result = (float) ((arg1)->right);
64718   jresult = result;
64719   return jresult;
64720 }
64721
64722
64723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64724   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64725   float arg2 ;
64726
64727   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64728   arg2 = (float)jarg2;
64729   if (arg1) (arg1)->top = arg2;
64730 }
64731
64732
64733 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64734   float jresult ;
64735   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64736   float result;
64737
64738   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64739   result = (float) ((arg1)->top);
64740   jresult = result;
64741   return jresult;
64742 }
64743
64744
64745 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64746   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64747   float arg2 ;
64748
64749   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64750   arg2 = (float)jarg2;
64751   if (arg1) (arg1)->bottom = arg2;
64752 }
64753
64754
64755 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64756   float jresult ;
64757   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64758   float result;
64759
64760   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64761   result = (float) ((arg1)->bottom);
64762   jresult = result;
64763   return jresult;
64764 }
64765
64766
64767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64768   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64769
64770   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64771   {
64772     try {
64773       delete arg1;
64774     } catch (std::out_of_range& e) {
64775       {
64776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64777       };
64778     } catch (std::exception& e) {
64779       {
64780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64781       };
64782     } catch (Dali::DaliException e) {
64783       {
64784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64785       };
64786     } catch (...) {
64787       {
64788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64789       };
64790     }
64791   }
64792
64793 }
64794
64795
64796 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64797   void * jresult ;
64798   Dali::Toolkit::Alignment *result = 0 ;
64799
64800   {
64801     try {
64802       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64803     } catch (std::out_of_range& e) {
64804       {
64805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64806       };
64807     } catch (std::exception& e) {
64808       {
64809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64810       };
64811     } catch (Dali::DaliException e) {
64812       {
64813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64814       };
64815     } catch (...) {
64816       {
64817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64818       };
64819     }
64820   }
64821
64822   jresult = (void *)result;
64823   return jresult;
64824 }
64825
64826
64827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64828   void * jresult ;
64829   Dali::Toolkit::Alignment::Type arg1 ;
64830   Dali::Toolkit::Alignment::Type arg2 ;
64831   Dali::Toolkit::Alignment result;
64832
64833   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64834   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64835   {
64836     try {
64837       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64838     } catch (std::out_of_range& e) {
64839       {
64840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64841       };
64842     } catch (std::exception& e) {
64843       {
64844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64845       };
64846     } catch (Dali::DaliException e) {
64847       {
64848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64849       };
64850     } catch (...) {
64851       {
64852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64853       };
64854     }
64855   }
64856
64857   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64858   return jresult;
64859 }
64860
64861
64862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64863   void * jresult ;
64864   Dali::Toolkit::Alignment::Type arg1 ;
64865   Dali::Toolkit::Alignment result;
64866
64867   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64868   {
64869     try {
64870       result = Dali::Toolkit::Alignment::New(arg1);
64871     } catch (std::out_of_range& e) {
64872       {
64873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64874       };
64875     } catch (std::exception& e) {
64876       {
64877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64878       };
64879     } catch (Dali::DaliException e) {
64880       {
64881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64882       };
64883     } catch (...) {
64884       {
64885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64886       };
64887     }
64888   }
64889
64890   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64891   return jresult;
64892 }
64893
64894
64895 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64896   void * jresult ;
64897   Dali::Toolkit::Alignment result;
64898
64899   {
64900     try {
64901       result = Dali::Toolkit::Alignment::New();
64902     } catch (std::out_of_range& e) {
64903       {
64904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64905       };
64906     } catch (std::exception& e) {
64907       {
64908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64909       };
64910     } catch (Dali::DaliException e) {
64911       {
64912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64913       };
64914     } catch (...) {
64915       {
64916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64917       };
64918     }
64919   }
64920
64921   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64922   return jresult;
64923 }
64924
64925
64926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64927   void * jresult ;
64928   Dali::Toolkit::Alignment *arg1 = 0 ;
64929   Dali::Toolkit::Alignment *result = 0 ;
64930
64931   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64932   if (!arg1) {
64933     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64934     return 0;
64935   }
64936   {
64937     try {
64938       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64939     } catch (std::out_of_range& e) {
64940       {
64941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64942       };
64943     } catch (std::exception& e) {
64944       {
64945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64946       };
64947     } catch (Dali::DaliException e) {
64948       {
64949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64950       };
64951     } catch (...) {
64952       {
64953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64954       };
64955     }
64956   }
64957
64958   jresult = (void *)result;
64959   return jresult;
64960 }
64961
64962
64963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64964   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64965
64966   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64967   {
64968     try {
64969       delete arg1;
64970     } catch (std::out_of_range& e) {
64971       {
64972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64973       };
64974     } catch (std::exception& e) {
64975       {
64976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64977       };
64978     } catch (Dali::DaliException e) {
64979       {
64980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64981       };
64982     } catch (...) {
64983       {
64984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64985       };
64986     }
64987   }
64988
64989 }
64990
64991
64992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64993   void * jresult ;
64994   Dali::BaseHandle arg1 ;
64995   Dali::BaseHandle *argp1 ;
64996   Dali::Toolkit::Alignment result;
64997
64998   argp1 = (Dali::BaseHandle *)jarg1;
64999   if (!argp1) {
65000     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65001     return 0;
65002   }
65003   arg1 = *argp1;
65004   {
65005     try {
65006       result = Dali::Toolkit::Alignment::DownCast(arg1);
65007     } catch (std::out_of_range& e) {
65008       {
65009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65010       };
65011     } catch (std::exception& e) {
65012       {
65013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65014       };
65015     } catch (Dali::DaliException e) {
65016       {
65017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65018       };
65019     } catch (...) {
65020       {
65021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65022       };
65023     }
65024   }
65025
65026   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
65027   return jresult;
65028 }
65029
65030
65031 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
65032   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65033   Dali::Toolkit::Alignment::Type arg2 ;
65034
65035   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65036   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
65037   {
65038     try {
65039       (arg1)->SetAlignmentType(arg2);
65040     } catch (std::out_of_range& e) {
65041       {
65042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65043       };
65044     } catch (std::exception& e) {
65045       {
65046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65047       };
65048     } catch (Dali::DaliException e) {
65049       {
65050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65051       };
65052     } catch (...) {
65053       {
65054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65055       };
65056     }
65057   }
65058
65059 }
65060
65061
65062 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
65063   int jresult ;
65064   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65065   Dali::Toolkit::Alignment::Type result;
65066
65067   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65068   {
65069     try {
65070       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
65071     } catch (std::out_of_range& e) {
65072       {
65073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65074       };
65075     } catch (std::exception& e) {
65076       {
65077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65078       };
65079     } catch (Dali::DaliException e) {
65080       {
65081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65082       };
65083     } catch (...) {
65084       {
65085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65086       };
65087     }
65088   }
65089
65090   jresult = (int)result;
65091   return jresult;
65092 }
65093
65094
65095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
65096   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65097   Dali::Toolkit::Alignment::Scaling arg2 ;
65098
65099   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65100   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
65101   {
65102     try {
65103       (arg1)->SetScaling(arg2);
65104     } catch (std::out_of_range& e) {
65105       {
65106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65107       };
65108     } catch (std::exception& e) {
65109       {
65110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65111       };
65112     } catch (Dali::DaliException e) {
65113       {
65114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65115       };
65116     } catch (...) {
65117       {
65118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65119       };
65120     }
65121   }
65122
65123 }
65124
65125
65126 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
65127   int jresult ;
65128   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65129   Dali::Toolkit::Alignment::Scaling result;
65130
65131   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65132   {
65133     try {
65134       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
65135     } catch (std::out_of_range& e) {
65136       {
65137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65138       };
65139     } catch (std::exception& e) {
65140       {
65141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65142       };
65143     } catch (Dali::DaliException e) {
65144       {
65145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65146       };
65147     } catch (...) {
65148       {
65149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65150       };
65151     }
65152   }
65153
65154   jresult = (int)result;
65155   return jresult;
65156 }
65157
65158
65159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
65160   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65161   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
65162
65163   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65164   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
65165   if (!arg2) {
65166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
65167     return ;
65168   }
65169   {
65170     try {
65171       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
65172     } catch (std::out_of_range& e) {
65173       {
65174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65175       };
65176     } catch (std::exception& e) {
65177       {
65178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65179       };
65180     } catch (Dali::DaliException e) {
65181       {
65182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65183       };
65184     } catch (...) {
65185       {
65186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65187       };
65188     }
65189   }
65190
65191 }
65192
65193
65194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
65195   void * jresult ;
65196   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65197   Dali::Toolkit::Alignment::Padding *result = 0 ;
65198
65199   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65200   {
65201     try {
65202       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
65203     } catch (std::out_of_range& e) {
65204       {
65205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65206       };
65207     } catch (std::exception& e) {
65208       {
65209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65210       };
65211     } catch (Dali::DaliException e) {
65212       {
65213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65214       };
65215     } catch (...) {
65216       {
65217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65218       };
65219     }
65220   }
65221
65222   jresult = (void *)result;
65223   return jresult;
65224 }
65225
65226
65227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
65228   void * jresult ;
65229   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
65230   Dali::Toolkit::Alignment *arg2 = 0 ;
65231   Dali::Toolkit::Alignment *result = 0 ;
65232
65233   arg1 = (Dali::Toolkit::Alignment *)jarg1;
65234   arg2 = (Dali::Toolkit::Alignment *)jarg2;
65235   if (!arg2) {
65236     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
65237     return 0;
65238   }
65239   {
65240     try {
65241       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
65242     } catch (std::out_of_range& e) {
65243       {
65244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65245       };
65246     } catch (std::exception& e) {
65247       {
65248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65249       };
65250     } catch (Dali::DaliException e) {
65251       {
65252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65253       };
65254     } catch (...) {
65255       {
65256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65257       };
65258     }
65259   }
65260
65261   jresult = (void *)result;
65262   return jresult;
65263 }
65264
65265
65266 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
65267   int jresult ;
65268   int result;
65269
65270   result = (int)Dali::Toolkit::Button::Property::DISABLED;
65271   jresult = (int)result;
65272   return jresult;
65273 }
65274
65275
65276 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
65277   int jresult ;
65278   int result;
65279
65280   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
65281   jresult = (int)result;
65282   return jresult;
65283 }
65284
65285
65286 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
65287   int jresult ;
65288   int result;
65289
65290   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
65291   jresult = (int)result;
65292   return jresult;
65293 }
65294
65295
65296 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
65297   int jresult ;
65298   int result;
65299
65300   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
65301   jresult = (int)result;
65302   return jresult;
65303 }
65304
65305
65306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
65307   int jresult ;
65308   int result;
65309
65310   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
65311   jresult = (int)result;
65312   return jresult;
65313 }
65314
65315
65316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
65317   int jresult ;
65318   int result;
65319
65320   result = (int)Dali::Toolkit::Button::Property::SELECTED;
65321   jresult = (int)result;
65322   return jresult;
65323 }
65324
65325 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
65326   int jresult ;
65327   int result;
65328
65329   result = (int)Dali::Toolkit::Button::Property::LABEL;
65330   jresult = (int)result;
65331   return jresult;
65332 }
65333
65334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
65335   void * jresult ;
65336   Dali::Toolkit::Button::Property *result = 0 ;
65337
65338   {
65339     try {
65340       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
65341     } catch (std::out_of_range& e) {
65342       {
65343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65344       };
65345     } catch (std::exception& e) {
65346       {
65347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65348       };
65349     } catch (Dali::DaliException e) {
65350       {
65351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65352       };
65353     } catch (...) {
65354       {
65355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65356       };
65357     }
65358   }
65359
65360   jresult = (void *)result;
65361   return jresult;
65362 }
65363
65364
65365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
65366   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
65367
65368   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
65369   {
65370     try {
65371       delete arg1;
65372     } catch (std::out_of_range& e) {
65373       {
65374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65375       };
65376     } catch (std::exception& e) {
65377       {
65378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65379       };
65380     } catch (Dali::DaliException e) {
65381       {
65382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65383       };
65384     } catch (...) {
65385       {
65386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65387       };
65388     }
65389   }
65390
65391 }
65392
65393
65394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
65395   void * jresult ;
65396   Dali::Toolkit::Button *result = 0 ;
65397
65398   {
65399     try {
65400       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
65401     } catch (std::out_of_range& e) {
65402       {
65403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65404       };
65405     } catch (std::exception& e) {
65406       {
65407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65408       };
65409     } catch (Dali::DaliException e) {
65410       {
65411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65412       };
65413     } catch (...) {
65414       {
65415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65416       };
65417     }
65418   }
65419
65420   jresult = (void *)result;
65421   return jresult;
65422 }
65423
65424
65425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
65426   void * jresult ;
65427   Dali::Toolkit::Button *arg1 = 0 ;
65428   Dali::Toolkit::Button *result = 0 ;
65429
65430   arg1 = (Dali::Toolkit::Button *)jarg1;
65431   if (!arg1) {
65432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65433     return 0;
65434   }
65435   {
65436     try {
65437       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
65438     } catch (std::out_of_range& e) {
65439       {
65440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65441       };
65442     } catch (std::exception& e) {
65443       {
65444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65445       };
65446     } catch (Dali::DaliException e) {
65447       {
65448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65449       };
65450     } catch (...) {
65451       {
65452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65453       };
65454     }
65455   }
65456
65457   jresult = (void *)result;
65458   return jresult;
65459 }
65460
65461
65462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
65463   void * jresult ;
65464   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65465   Dali::Toolkit::Button *arg2 = 0 ;
65466   Dali::Toolkit::Button *result = 0 ;
65467
65468   arg1 = (Dali::Toolkit::Button *)jarg1;
65469   arg2 = (Dali::Toolkit::Button *)jarg2;
65470   if (!arg2) {
65471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
65472     return 0;
65473   }
65474   {
65475     try {
65476       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
65477     } catch (std::out_of_range& e) {
65478       {
65479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65480       };
65481     } catch (std::exception& e) {
65482       {
65483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65484       };
65485     } catch (Dali::DaliException e) {
65486       {
65487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65488       };
65489     } catch (...) {
65490       {
65491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65492       };
65493     }
65494   }
65495
65496   jresult = (void *)result;
65497   return jresult;
65498 }
65499
65500
65501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65502   void * jresult ;
65503   Dali::BaseHandle arg1 ;
65504   Dali::BaseHandle *argp1 ;
65505   Dali::Toolkit::Button result;
65506
65507   argp1 = (Dali::BaseHandle *)jarg1;
65508   if (!argp1) {
65509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65510     return 0;
65511   }
65512   arg1 = *argp1;
65513   {
65514     try {
65515       result = Dali::Toolkit::Button::DownCast(arg1);
65516     } catch (std::out_of_range& e) {
65517       {
65518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65519       };
65520     } catch (std::exception& e) {
65521       {
65522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65523       };
65524     } catch (Dali::DaliException e) {
65525       {
65526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65527       };
65528     } catch (...) {
65529       {
65530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65531       };
65532     }
65533   }
65534
65535   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65536   return jresult;
65537 }
65538
65539
65540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65541   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65542
65543   arg1 = (Dali::Toolkit::Button *)jarg1;
65544   {
65545     try {
65546       delete arg1;
65547     } catch (std::out_of_range& e) {
65548       {
65549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65550       };
65551     } catch (std::exception& e) {
65552       {
65553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65554       };
65555     } catch (Dali::DaliException e) {
65556       {
65557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65558       };
65559     } catch (...) {
65560       {
65561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65562       };
65563     }
65564   }
65565
65566 }
65567
65568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65569   void * jresult ;
65570   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65571   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65572
65573   arg1 = (Dali::Toolkit::Button *)jarg1;
65574   {
65575     try {
65576       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65577     } catch (std::out_of_range& e) {
65578       {
65579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65580       };
65581     } catch (std::exception& e) {
65582       {
65583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65584       };
65585     } catch (Dali::DaliException e) {
65586       {
65587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65588       };
65589     } catch (...) {
65590       {
65591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65592       };
65593     }
65594   }
65595
65596   jresult = (void *)result;
65597   return jresult;
65598 }
65599
65600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65601   void * jresult ;
65602   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65603   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65604
65605   arg1 = (Dali::Toolkit::Button *)jarg1;
65606   {
65607     try {
65608       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65609     } catch (std::out_of_range& e) {
65610       {
65611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65612       };
65613     } catch (std::exception& e) {
65614       {
65615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65616       };
65617     } catch (Dali::DaliException e) {
65618       {
65619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65620       };
65621     } catch (...) {
65622       {
65623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65624       };
65625     }
65626   }
65627
65628   jresult = (void *)result;
65629   return jresult;
65630 }
65631
65632
65633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65634   void * jresult ;
65635   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65636   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65637
65638   arg1 = (Dali::Toolkit::Button *)jarg1;
65639   {
65640     try {
65641       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65642     } catch (std::out_of_range& e) {
65643       {
65644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65645       };
65646     } catch (std::exception& e) {
65647       {
65648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65649       };
65650     } catch (Dali::DaliException e) {
65651       {
65652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65653       };
65654     } catch (...) {
65655       {
65656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65657       };
65658     }
65659   }
65660
65661   jresult = (void *)result;
65662   return jresult;
65663 }
65664
65665
65666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65667   void * jresult ;
65668   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65669   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65670
65671   arg1 = (Dali::Toolkit::Button *)jarg1;
65672   {
65673     try {
65674       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65675     } catch (std::out_of_range& e) {
65676       {
65677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65678       };
65679     } catch (std::exception& e) {
65680       {
65681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65682       };
65683     } catch (Dali::DaliException e) {
65684       {
65685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65686       };
65687     } catch (...) {
65688       {
65689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65690       };
65691     }
65692   }
65693
65694   jresult = (void *)result;
65695   return jresult;
65696 }
65697
65698
65699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65700   void * jresult ;
65701   Dali::Toolkit::CheckBoxButton *result = 0 ;
65702
65703   {
65704     try {
65705       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65706     } catch (std::out_of_range& e) {
65707       {
65708         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65709       };
65710     } catch (std::exception& e) {
65711       {
65712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65713       };
65714     } catch (Dali::DaliException e) {
65715       {
65716         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65717       };
65718     } catch (...) {
65719       {
65720         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65721       };
65722     }
65723   }
65724
65725   jresult = (void *)result;
65726   return jresult;
65727 }
65728
65729
65730 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65731   void * jresult ;
65732   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65733   Dali::Toolkit::CheckBoxButton *result = 0 ;
65734
65735   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65736   if (!arg1) {
65737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65738     return 0;
65739   }
65740   {
65741     try {
65742       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65743     } catch (std::out_of_range& e) {
65744       {
65745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65746       };
65747     } catch (std::exception& e) {
65748       {
65749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65750       };
65751     } catch (Dali::DaliException e) {
65752       {
65753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65754       };
65755     } catch (...) {
65756       {
65757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65758       };
65759     }
65760   }
65761
65762   jresult = (void *)result;
65763   return jresult;
65764 }
65765
65766
65767 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65768   void * jresult ;
65769   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65770   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65771   Dali::Toolkit::CheckBoxButton *result = 0 ;
65772
65773   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65774   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65775   if (!arg2) {
65776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65777     return 0;
65778   }
65779   {
65780     try {
65781       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65782     } catch (std::out_of_range& e) {
65783       {
65784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65785       };
65786     } catch (std::exception& e) {
65787       {
65788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65789       };
65790     } catch (Dali::DaliException e) {
65791       {
65792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65793       };
65794     } catch (...) {
65795       {
65796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65797       };
65798     }
65799   }
65800
65801   jresult = (void *)result;
65802   return jresult;
65803 }
65804
65805
65806 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65807   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65808
65809   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65810   {
65811     try {
65812       delete arg1;
65813     } catch (std::out_of_range& e) {
65814       {
65815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65816       };
65817     } catch (std::exception& e) {
65818       {
65819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65820       };
65821     } catch (Dali::DaliException e) {
65822       {
65823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65824       };
65825     } catch (...) {
65826       {
65827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65828       };
65829     }
65830   }
65831
65832 }
65833
65834
65835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65836   void * jresult ;
65837   Dali::Toolkit::CheckBoxButton result;
65838
65839   {
65840     try {
65841       result = Dali::Toolkit::CheckBoxButton::New();
65842     } catch (std::out_of_range& e) {
65843       {
65844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65845       };
65846     } catch (std::exception& e) {
65847       {
65848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65849       };
65850     } catch (Dali::DaliException e) {
65851       {
65852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65853       };
65854     } catch (...) {
65855       {
65856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65857       };
65858     }
65859   }
65860
65861   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65862   return jresult;
65863 }
65864
65865
65866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65867   void * jresult ;
65868   Dali::BaseHandle arg1 ;
65869   Dali::BaseHandle *argp1 ;
65870   Dali::Toolkit::CheckBoxButton result;
65871
65872   argp1 = (Dali::BaseHandle *)jarg1;
65873   if (!argp1) {
65874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65875     return 0;
65876   }
65877   arg1 = *argp1;
65878   {
65879     try {
65880       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65881     } catch (std::out_of_range& e) {
65882       {
65883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65884       };
65885     } catch (std::exception& e) {
65886       {
65887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65888       };
65889     } catch (Dali::DaliException e) {
65890       {
65891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65892       };
65893     } catch (...) {
65894       {
65895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65896       };
65897     }
65898   }
65899
65900   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65901   return jresult;
65902 }
65903
65904
65905 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65906   int jresult ;
65907   int result;
65908
65909   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65910   jresult = (int)result;
65911   return jresult;
65912 }
65913
65914
65915 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65916   int jresult ;
65917   int result;
65918
65919   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65920   jresult = (int)result;
65921   return jresult;
65922 }
65923
65924
65925 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65926   void * jresult ;
65927   Dali::Toolkit::PushButton::Property *result = 0 ;
65928
65929   {
65930     try {
65931       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65932     } catch (std::out_of_range& e) {
65933       {
65934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65935       };
65936     } catch (std::exception& e) {
65937       {
65938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65939       };
65940     } catch (Dali::DaliException e) {
65941       {
65942         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65943       };
65944     } catch (...) {
65945       {
65946         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65947       };
65948     }
65949   }
65950
65951   jresult = (void *)result;
65952   return jresult;
65953 }
65954
65955
65956 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65957   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65958
65959   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65960   {
65961     try {
65962       delete arg1;
65963     } catch (std::out_of_range& e) {
65964       {
65965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65966       };
65967     } catch (std::exception& e) {
65968       {
65969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65970       };
65971     } catch (Dali::DaliException e) {
65972       {
65973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65974       };
65975     } catch (...) {
65976       {
65977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65978       };
65979     }
65980   }
65981
65982 }
65983
65984
65985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65986   void * jresult ;
65987   Dali::Toolkit::PushButton *result = 0 ;
65988
65989   {
65990     try {
65991       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65992     } catch (std::out_of_range& e) {
65993       {
65994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65995       };
65996     } catch (std::exception& e) {
65997       {
65998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65999       };
66000     } catch (Dali::DaliException e) {
66001       {
66002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66003       };
66004     } catch (...) {
66005       {
66006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66007       };
66008     }
66009   }
66010
66011   jresult = (void *)result;
66012   return jresult;
66013 }
66014
66015
66016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
66017   void * jresult ;
66018   Dali::Toolkit::PushButton *arg1 = 0 ;
66019   Dali::Toolkit::PushButton *result = 0 ;
66020
66021   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66022   if (!arg1) {
66023     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66024     return 0;
66025   }
66026   {
66027     try {
66028       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
66029     } catch (std::out_of_range& e) {
66030       {
66031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66032       };
66033     } catch (std::exception& e) {
66034       {
66035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66036       };
66037     } catch (Dali::DaliException e) {
66038       {
66039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66040       };
66041     } catch (...) {
66042       {
66043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66044       };
66045     }
66046   }
66047
66048   jresult = (void *)result;
66049   return jresult;
66050 }
66051
66052
66053 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
66054   void * jresult ;
66055   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66056   Dali::Toolkit::PushButton *arg2 = 0 ;
66057   Dali::Toolkit::PushButton *result = 0 ;
66058
66059   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66060   arg2 = (Dali::Toolkit::PushButton *)jarg2;
66061   if (!arg2) {
66062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
66063     return 0;
66064   }
66065   {
66066     try {
66067       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
66068     } catch (std::out_of_range& e) {
66069       {
66070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66071       };
66072     } catch (std::exception& e) {
66073       {
66074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66075       };
66076     } catch (Dali::DaliException e) {
66077       {
66078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66079       };
66080     } catch (...) {
66081       {
66082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66083       };
66084     }
66085   }
66086
66087   jresult = (void *)result;
66088   return jresult;
66089 }
66090
66091
66092 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
66093   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
66094
66095   arg1 = (Dali::Toolkit::PushButton *)jarg1;
66096   {
66097     try {
66098       delete arg1;
66099     } catch (std::out_of_range& e) {
66100       {
66101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66102       };
66103     } catch (std::exception& e) {
66104       {
66105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66106       };
66107     } catch (Dali::DaliException e) {
66108       {
66109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66110       };
66111     } catch (...) {
66112       {
66113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66114       };
66115     }
66116   }
66117
66118 }
66119
66120
66121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
66122   void * jresult ;
66123   Dali::Toolkit::PushButton result;
66124
66125   {
66126     try {
66127       result = Dali::Toolkit::PushButton::New();
66128     } catch (std::out_of_range& e) {
66129       {
66130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66131       };
66132     } catch (std::exception& e) {
66133       {
66134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66135       };
66136     } catch (Dali::DaliException e) {
66137       {
66138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66139       };
66140     } catch (...) {
66141       {
66142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66143       };
66144     }
66145   }
66146
66147   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66148   return jresult;
66149 }
66150
66151
66152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
66153   void * jresult ;
66154   Dali::BaseHandle arg1 ;
66155   Dali::BaseHandle *argp1 ;
66156   Dali::Toolkit::PushButton result;
66157
66158   argp1 = (Dali::BaseHandle *)jarg1;
66159   if (!argp1) {
66160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66161     return 0;
66162   }
66163   arg1 = *argp1;
66164   {
66165     try {
66166       result = Dali::Toolkit::PushButton::DownCast(arg1);
66167     } catch (std::out_of_range& e) {
66168       {
66169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66170       };
66171     } catch (std::exception& e) {
66172       {
66173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66174       };
66175     } catch (Dali::DaliException e) {
66176       {
66177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66178       };
66179     } catch (...) {
66180       {
66181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66182       };
66183     }
66184   }
66185
66186   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
66187   return jresult;
66188 }
66189
66190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
66191   void * jresult ;
66192   Dali::Toolkit::RadioButton *result = 0 ;
66193
66194   {
66195     try {
66196       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
66197     } catch (std::out_of_range& e) {
66198       {
66199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66200       };
66201     } catch (std::exception& e) {
66202       {
66203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66204       };
66205     } catch (Dali::DaliException e) {
66206       {
66207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66208       };
66209     } catch (...) {
66210       {
66211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66212       };
66213     }
66214   }
66215
66216   jresult = (void *)result;
66217   return jresult;
66218 }
66219
66220
66221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
66222   void * jresult ;
66223   Dali::Toolkit::RadioButton *arg1 = 0 ;
66224   Dali::Toolkit::RadioButton *result = 0 ;
66225
66226   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66227   if (!arg1) {
66228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66229     return 0;
66230   }
66231   {
66232     try {
66233       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
66234     } catch (std::out_of_range& e) {
66235       {
66236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66237       };
66238     } catch (std::exception& e) {
66239       {
66240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66241       };
66242     } catch (Dali::DaliException e) {
66243       {
66244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66245       };
66246     } catch (...) {
66247       {
66248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66249       };
66250     }
66251   }
66252
66253   jresult = (void *)result;
66254   return jresult;
66255 }
66256
66257
66258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
66259   void * jresult ;
66260   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66261   Dali::Toolkit::RadioButton *arg2 = 0 ;
66262   Dali::Toolkit::RadioButton *result = 0 ;
66263
66264   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66265   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
66266   if (!arg2) {
66267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
66268     return 0;
66269   }
66270   {
66271     try {
66272       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
66273     } catch (std::out_of_range& e) {
66274       {
66275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66276       };
66277     } catch (std::exception& e) {
66278       {
66279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66280       };
66281     } catch (Dali::DaliException e) {
66282       {
66283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66284       };
66285     } catch (...) {
66286       {
66287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66288       };
66289     }
66290   }
66291
66292   jresult = (void *)result;
66293   return jresult;
66294 }
66295
66296
66297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
66298   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
66299
66300   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
66301   {
66302     try {
66303       delete arg1;
66304     } catch (std::out_of_range& e) {
66305       {
66306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66307       };
66308     } catch (std::exception& e) {
66309       {
66310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66311       };
66312     } catch (Dali::DaliException e) {
66313       {
66314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66315       };
66316     } catch (...) {
66317       {
66318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66319       };
66320     }
66321   }
66322
66323 }
66324
66325
66326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
66327   void * jresult ;
66328   Dali::Toolkit::RadioButton result;
66329
66330   {
66331     try {
66332       result = Dali::Toolkit::RadioButton::New();
66333     } catch (std::out_of_range& e) {
66334       {
66335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66336       };
66337     } catch (std::exception& e) {
66338       {
66339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66340       };
66341     } catch (Dali::DaliException e) {
66342       {
66343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66344       };
66345     } catch (...) {
66346       {
66347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66348       };
66349     }
66350   }
66351
66352   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66353   return jresult;
66354 }
66355
66356
66357 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
66358   void * jresult ;
66359   std::string *arg1 = 0 ;
66360   Dali::Toolkit::RadioButton result;
66361
66362   if (!jarg1) {
66363     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66364     return 0;
66365   }
66366   std::string arg1_str(jarg1);
66367   arg1 = &arg1_str;
66368   {
66369     try {
66370       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
66371     } catch (std::out_of_range& e) {
66372       {
66373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66374       };
66375     } catch (std::exception& e) {
66376       {
66377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66378       };
66379     } catch (Dali::DaliException e) {
66380       {
66381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66382       };
66383     } catch (...) {
66384       {
66385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66386       };
66387     }
66388   }
66389
66390   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66391
66392   //argout typemap for const std::string&
66393
66394   return jresult;
66395 }
66396
66397
66398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
66399   void * jresult ;
66400   Dali::BaseHandle arg1 ;
66401   Dali::BaseHandle *argp1 ;
66402   Dali::Toolkit::RadioButton result;
66403
66404   argp1 = (Dali::BaseHandle *)jarg1;
66405   if (!argp1) {
66406     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66407     return 0;
66408   }
66409   arg1 = *argp1;
66410   {
66411     try {
66412       result = Dali::Toolkit::RadioButton::DownCast(arg1);
66413     } catch (std::out_of_range& e) {
66414       {
66415         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66416       };
66417     } catch (std::exception& e) {
66418       {
66419         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66420       };
66421     } catch (Dali::DaliException e) {
66422       {
66423         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66424       };
66425     } catch (...) {
66426       {
66427         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66428       };
66429     }
66430   }
66431
66432   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
66433   return jresult;
66434 }
66435
66436
66437 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
66438   int jresult ;
66439   int result;
66440
66441   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
66442   jresult = (int)result;
66443   return jresult;
66444 }
66445
66446
66447 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
66448   int jresult ;
66449   int result;
66450
66451   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
66452   jresult = (int)result;
66453   return jresult;
66454 }
66455
66456
66457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
66458   int jresult ;
66459   int result;
66460
66461   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
66462   jresult = (int)result;
66463   return jresult;
66464 }
66465
66466
66467 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
66468   int jresult ;
66469   int result;
66470
66471   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
66472   jresult = (int)result;
66473   return jresult;
66474 }
66475
66476
66477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
66478   int jresult ;
66479   int result;
66480
66481   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
66482   jresult = (int)result;
66483   return jresult;
66484 }
66485
66486
66487 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
66488   int jresult ;
66489   int result;
66490
66491   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
66492   jresult = (int)result;
66493   return jresult;
66494 }
66495
66496
66497 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66498   void * jresult ;
66499   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66500
66501   {
66502     try {
66503       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66504     } catch (std::out_of_range& e) {
66505       {
66506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66507       };
66508     } catch (std::exception& e) {
66509       {
66510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66511       };
66512     } catch (Dali::DaliException e) {
66513       {
66514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66515       };
66516     } catch (...) {
66517       {
66518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66519       };
66520     }
66521   }
66522
66523   jresult = (void *)result;
66524   return jresult;
66525 }
66526
66527
66528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66529   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66530
66531   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66532   {
66533     try {
66534       delete arg1;
66535     } catch (std::out_of_range& e) {
66536       {
66537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66538       };
66539     } catch (std::exception& e) {
66540       {
66541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66542       };
66543     } catch (Dali::DaliException e) {
66544       {
66545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66546       };
66547     } catch (...) {
66548       {
66549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66550       };
66551     }
66552   }
66553
66554 }
66555
66556
66557 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66558   int jresult ;
66559   int result;
66560
66561   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66562   jresult = (int)result;
66563   return jresult;
66564 }
66565
66566
66567 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66568   int jresult ;
66569   int result;
66570
66571   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66572   jresult = (int)result;
66573   return jresult;
66574 }
66575
66576
66577 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66578   int jresult ;
66579   int result;
66580
66581   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66582   jresult = (int)result;
66583   return jresult;
66584 }
66585
66586
66587 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66588   void * jresult ;
66589   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66590
66591   {
66592     try {
66593       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66594     } catch (std::out_of_range& e) {
66595       {
66596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66597       };
66598     } catch (std::exception& e) {
66599       {
66600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66601       };
66602     } catch (Dali::DaliException e) {
66603       {
66604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66605       };
66606     } catch (...) {
66607       {
66608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66609       };
66610     }
66611   }
66612
66613   jresult = (void *)result;
66614   return jresult;
66615 }
66616
66617
66618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66619   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66620
66621   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66622   {
66623     try {
66624       delete arg1;
66625     } catch (std::out_of_range& e) {
66626       {
66627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66628       };
66629     } catch (std::exception& e) {
66630       {
66631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66632       };
66633     } catch (Dali::DaliException e) {
66634       {
66635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66636       };
66637     } catch (...) {
66638       {
66639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66640       };
66641     }
66642   }
66643
66644 }
66645
66646
66647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66648   void * jresult ;
66649   Dali::Toolkit::FlexContainer *result = 0 ;
66650
66651   {
66652     try {
66653       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66654     } catch (std::out_of_range& e) {
66655       {
66656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66657       };
66658     } catch (std::exception& e) {
66659       {
66660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66661       };
66662     } catch (Dali::DaliException e) {
66663       {
66664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66665       };
66666     } catch (...) {
66667       {
66668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66669       };
66670     }
66671   }
66672
66673   jresult = (void *)result;
66674   return jresult;
66675 }
66676
66677
66678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66679   void * jresult ;
66680   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66681   Dali::Toolkit::FlexContainer *result = 0 ;
66682
66683   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66684   if (!arg1) {
66685     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66686     return 0;
66687   }
66688   {
66689     try {
66690       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66691     } catch (std::out_of_range& e) {
66692       {
66693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66694       };
66695     } catch (std::exception& e) {
66696       {
66697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66698       };
66699     } catch (Dali::DaliException e) {
66700       {
66701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66702       };
66703     } catch (...) {
66704       {
66705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66706       };
66707     }
66708   }
66709
66710   jresult = (void *)result;
66711   return jresult;
66712 }
66713
66714
66715 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66716   void * jresult ;
66717   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66718   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66719   Dali::Toolkit::FlexContainer *result = 0 ;
66720
66721   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66722   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66723   if (!arg2) {
66724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66725     return 0;
66726   }
66727   {
66728     try {
66729       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
66730     } catch (std::out_of_range& e) {
66731       {
66732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66733       };
66734     } catch (std::exception& e) {
66735       {
66736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66737       };
66738     } catch (Dali::DaliException e) {
66739       {
66740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66741       };
66742     } catch (...) {
66743       {
66744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66745       };
66746     }
66747   }
66748
66749   jresult = (void *)result;
66750   return jresult;
66751 }
66752
66753
66754 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer(void * jarg1) {
66755   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66756
66757   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66758   {
66759     try {
66760       delete arg1;
66761     } catch (std::out_of_range& e) {
66762       {
66763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66764       };
66765     } catch (std::exception& e) {
66766       {
66767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66768       };
66769     } catch (Dali::DaliException e) {
66770       {
66771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66772       };
66773     } catch (...) {
66774       {
66775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66776       };
66777     }
66778   }
66779
66780 }
66781
66782
66783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66784   void * jresult ;
66785   Dali::Toolkit::FlexContainer result;
66786
66787   {
66788     try {
66789       result = Dali::Toolkit::FlexContainer::New();
66790     } catch (std::out_of_range& e) {
66791       {
66792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66793       };
66794     } catch (std::exception& e) {
66795       {
66796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66797       };
66798     } catch (Dali::DaliException e) {
66799       {
66800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66801       };
66802     } catch (...) {
66803       {
66804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66805       };
66806     }
66807   }
66808
66809   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66810   return jresult;
66811 }
66812
66813
66814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66815   void * jresult ;
66816   Dali::BaseHandle arg1 ;
66817   Dali::BaseHandle *argp1 ;
66818   Dali::Toolkit::FlexContainer result;
66819
66820   argp1 = (Dali::BaseHandle *)jarg1;
66821   if (!argp1) {
66822     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66823     return 0;
66824   }
66825   arg1 = *argp1;
66826   {
66827     try {
66828       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
66829     } catch (std::out_of_range& e) {
66830       {
66831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66832       };
66833     } catch (std::exception& e) {
66834       {
66835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66836       };
66837     } catch (Dali::DaliException e) {
66838       {
66839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66840       };
66841     } catch (...) {
66842       {
66843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66844       };
66845     }
66846   }
66847
66848   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66849   return jresult;
66850 }
66851
66852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66853   int jresult ;
66854   int result;
66855
66856   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66857   jresult = (int)result;
66858   return jresult;
66859 }
66860
66861
66862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66863   int jresult ;
66864   int result;
66865
66866   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66867   jresult = (int)result;
66868   return jresult;
66869 }
66870
66871
66872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66873   int jresult ;
66874   int result;
66875
66876   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66877   jresult = (int)result;
66878   return jresult;
66879 }
66880
66881
66882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66883   void * jresult ;
66884   Dali::Toolkit::ImageView::Property *result = 0 ;
66885
66886   {
66887     try {
66888       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66889     } catch (std::out_of_range& e) {
66890       {
66891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66892       };
66893     } catch (std::exception& e) {
66894       {
66895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66896       };
66897     } catch (Dali::DaliException e) {
66898       {
66899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66900       };
66901     } catch (...) {
66902       {
66903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66904       };
66905     }
66906   }
66907
66908   jresult = (void *)result;
66909   return jresult;
66910 }
66911
66912
66913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66914   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66915
66916   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66917   {
66918     try {
66919       delete arg1;
66920     } catch (std::out_of_range& e) {
66921       {
66922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66923       };
66924     } catch (std::exception& e) {
66925       {
66926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66927       };
66928     } catch (Dali::DaliException e) {
66929       {
66930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66931       };
66932     } catch (...) {
66933       {
66934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66935       };
66936     }
66937   }
66938
66939 }
66940
66941
66942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66943   void * jresult ;
66944   Dali::Toolkit::ImageView *result = 0 ;
66945
66946   {
66947     try {
66948       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66949     } catch (std::out_of_range& e) {
66950       {
66951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66952       };
66953     } catch (std::exception& e) {
66954       {
66955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66956       };
66957     } catch (Dali::DaliException e) {
66958       {
66959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66960       };
66961     } catch (...) {
66962       {
66963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66964       };
66965     }
66966   }
66967
66968   jresult = (void *)result;
66969   return jresult;
66970 }
66971
66972
66973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66974   void * jresult ;
66975   Dali::Toolkit::ImageView result;
66976
66977   {
66978     try {
66979       result = Dali::Toolkit::ImageView::New();
66980     } catch (std::out_of_range& e) {
66981       {
66982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66983       };
66984     } catch (std::exception& e) {
66985       {
66986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66987       };
66988     } catch (Dali::DaliException e) {
66989       {
66990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66991       };
66992     } catch (...) {
66993       {
66994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66995       };
66996     }
66997   }
66998
66999   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67000   return jresult;
67001 }
67002
67003
67004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
67005   void * jresult ;
67006   std::string *arg1 = 0 ;
67007   Dali::Toolkit::ImageView result;
67008
67009   if (!jarg1) {
67010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67011     return 0;
67012   }
67013   std::string arg1_str(jarg1);
67014   arg1 = &arg1_str;
67015   {
67016     try {
67017       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
67018     } catch (std::out_of_range& e) {
67019       {
67020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67021       };
67022     } catch (std::exception& e) {
67023       {
67024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67025       };
67026     } catch (Dali::DaliException e) {
67027       {
67028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67029       };
67030     } catch (...) {
67031       {
67032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67033       };
67034     }
67035   }
67036
67037   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67038
67039   //argout typemap for const std::string&
67040
67041   return jresult;
67042 }
67043
67044
67045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
67046   void * jresult ;
67047   std::string *arg1 = 0 ;
67048   Dali::ImageDimensions arg2 ;
67049   Dali::ImageDimensions *argp2 ;
67050   Dali::Toolkit::ImageView result;
67051
67052   if (!jarg1) {
67053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67054     return 0;
67055   }
67056   std::string arg1_str(jarg1);
67057   arg1 = &arg1_str;
67058   argp2 = (Dali::ImageDimensions *)jarg2;
67059   if (!argp2) {
67060     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67061     return 0;
67062   }
67063   arg2 = *argp2;
67064   {
67065     try {
67066       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
67067     } catch (std::out_of_range& e) {
67068       {
67069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67070       };
67071     } catch (std::exception& e) {
67072       {
67073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67074       };
67075     } catch (Dali::DaliException e) {
67076       {
67077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67078       };
67079     } catch (...) {
67080       {
67081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67082       };
67083     }
67084   }
67085
67086   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67087
67088   //argout typemap for const std::string&
67089
67090   return jresult;
67091 }
67092
67093
67094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
67095   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67096
67097   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67098   {
67099     try {
67100       delete arg1;
67101     } catch (std::out_of_range& e) {
67102       {
67103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67104       };
67105     } catch (std::exception& e) {
67106       {
67107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67108       };
67109     } catch (Dali::DaliException e) {
67110       {
67111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67112       };
67113     } catch (...) {
67114       {
67115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67116       };
67117     }
67118   }
67119
67120 }
67121
67122
67123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
67124   void * jresult ;
67125   Dali::Toolkit::ImageView *arg1 = 0 ;
67126   Dali::Toolkit::ImageView *result = 0 ;
67127
67128   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67129   if (!arg1) {
67130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67131     return 0;
67132   }
67133   {
67134     try {
67135       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
67136     } catch (std::out_of_range& e) {
67137       {
67138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67139       };
67140     } catch (std::exception& e) {
67141       {
67142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67143       };
67144     } catch (Dali::DaliException e) {
67145       {
67146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67147       };
67148     } catch (...) {
67149       {
67150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67151       };
67152     }
67153   }
67154
67155   jresult = (void *)result;
67156   return jresult;
67157 }
67158
67159
67160 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
67161   void * jresult ;
67162   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67163   Dali::Toolkit::ImageView *arg2 = 0 ;
67164   Dali::Toolkit::ImageView *result = 0 ;
67165
67166   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67167   arg2 = (Dali::Toolkit::ImageView *)jarg2;
67168   if (!arg2) {
67169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
67170     return 0;
67171   }
67172   {
67173     try {
67174       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
67175     } catch (std::out_of_range& e) {
67176       {
67177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67178       };
67179     } catch (std::exception& e) {
67180       {
67181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67182       };
67183     } catch (Dali::DaliException e) {
67184       {
67185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67186       };
67187     } catch (...) {
67188       {
67189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67190       };
67191     }
67192   }
67193
67194   jresult = (void *)result;
67195   return jresult;
67196 }
67197
67198
67199 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
67200   void * jresult ;
67201   Dali::BaseHandle arg1 ;
67202   Dali::BaseHandle *argp1 ;
67203   Dali::Toolkit::ImageView result;
67204
67205   argp1 = (Dali::BaseHandle *)jarg1;
67206   if (!argp1) {
67207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67208     return 0;
67209   }
67210   arg1 = *argp1;
67211   {
67212     try {
67213       result = Dali::Toolkit::ImageView::DownCast(arg1);
67214     } catch (std::out_of_range& e) {
67215       {
67216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67217       };
67218     } catch (std::exception& e) {
67219       {
67220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67221       };
67222     } catch (Dali::DaliException e) {
67223       {
67224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67225       };
67226     } catch (...) {
67227       {
67228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67229       };
67230     }
67231   }
67232
67233   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
67234   return jresult;
67235 }
67236
67237
67238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
67239   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67240   std::string *arg2 = 0 ;
67241
67242   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67243   if (!jarg2) {
67244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67245     return ;
67246   }
67247   std::string arg2_str(jarg2);
67248   arg2 = &arg2_str;
67249   {
67250     try {
67251       (arg1)->SetImage((std::string const &)*arg2);
67252     } catch (std::out_of_range& e) {
67253       {
67254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67255       };
67256     } catch (std::exception& e) {
67257       {
67258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67259       };
67260     } catch (Dali::DaliException e) {
67261       {
67262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67263       };
67264     } catch (...) {
67265       {
67266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67267       };
67268     }
67269   }
67270
67271
67272   //argout typemap for const std::string&
67273
67274 }
67275
67276
67277 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
67278   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
67279   std::string *arg2 = 0 ;
67280   Dali::ImageDimensions arg3 ;
67281   Dali::ImageDimensions *argp3 ;
67282
67283   arg1 = (Dali::Toolkit::ImageView *)jarg1;
67284   if (!jarg2) {
67285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67286     return ;
67287   }
67288   std::string arg2_str(jarg2);
67289   arg2 = &arg2_str;
67290   argp3 = (Dali::ImageDimensions *)jarg3;
67291   if (!argp3) {
67292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
67293     return ;
67294   }
67295   arg3 = *argp3;
67296   {
67297     try {
67298       (arg1)->SetImage((std::string const &)*arg2,arg3);
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   //argout typemap for const std::string&
67320
67321 }
67322
67323
67324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
67325   int jresult ;
67326   int result;
67327
67328   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
67329   jresult = (int)result;
67330   return jresult;
67331 }
67332
67333
67334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
67335   int jresult ;
67336   int result;
67337
67338   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
67339   jresult = (int)result;
67340   return jresult;
67341 }
67342
67343
67344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
67345   int jresult ;
67346   int result;
67347
67348   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
67349   jresult = (int)result;
67350   return jresult;
67351 }
67352
67353
67354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
67355   int jresult ;
67356   int result;
67357
67358   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
67359   jresult = (int)result;
67360   return jresult;
67361 }
67362
67363
67364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
67365   int jresult ;
67366   int result;
67367
67368   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
67369   jresult = (int)result;
67370   return jresult;
67371 }
67372
67373
67374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
67375   int jresult ;
67376   int result;
67377
67378   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
67379   jresult = (int)result;
67380   return jresult;
67381 }
67382
67383
67384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
67385   int jresult ;
67386   int result;
67387
67388   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
67389   jresult = (int)result;
67390   return jresult;
67391 }
67392
67393
67394 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
67395   int jresult ;
67396   int result;
67397
67398   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
67399   jresult = (int)result;
67400   return jresult;
67401 }
67402
67403
67404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
67405   void * jresult ;
67406   Dali::Toolkit::Model3dView::Property *result = 0 ;
67407
67408   {
67409     try {
67410       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
67411     } catch (std::out_of_range& e) {
67412       {
67413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67414       };
67415     } catch (std::exception& e) {
67416       {
67417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67418       };
67419     } catch (Dali::DaliException e) {
67420       {
67421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67422       };
67423     } catch (...) {
67424       {
67425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67426       };
67427     }
67428   }
67429
67430   jresult = (void *)result;
67431   return jresult;
67432 }
67433
67434
67435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
67436   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
67437
67438   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
67439   {
67440     try {
67441       delete arg1;
67442     } catch (std::out_of_range& e) {
67443       {
67444         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67445       };
67446     } catch (std::exception& e) {
67447       {
67448         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67449       };
67450     } catch (Dali::DaliException e) {
67451       {
67452         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67453       };
67454     } catch (...) {
67455       {
67456         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67457       };
67458     }
67459   }
67460
67461 }
67462
67463
67464 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
67465   void * jresult ;
67466   Dali::Toolkit::Model3dView result;
67467
67468   {
67469     try {
67470       result = Dali::Toolkit::Model3dView::New();
67471     } catch (std::out_of_range& e) {
67472       {
67473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67474       };
67475     } catch (std::exception& e) {
67476       {
67477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67478       };
67479     } catch (Dali::DaliException e) {
67480       {
67481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67482       };
67483     } catch (...) {
67484       {
67485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67486       };
67487     }
67488   }
67489
67490   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67491   return jresult;
67492 }
67493
67494
67495 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67496   void * jresult ;
67497   std::string *arg1 = 0 ;
67498   std::string *arg2 = 0 ;
67499   std::string *arg3 = 0 ;
67500   Dali::Toolkit::Model3dView result;
67501
67502   if (!jarg1) {
67503     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67504     return 0;
67505   }
67506   std::string arg1_str(jarg1);
67507   arg1 = &arg1_str;
67508   if (!jarg2) {
67509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67510     return 0;
67511   }
67512   std::string arg2_str(jarg2);
67513   arg2 = &arg2_str;
67514   if (!jarg3) {
67515     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67516     return 0;
67517   }
67518   std::string arg3_str(jarg3);
67519   arg3 = &arg3_str;
67520   {
67521     try {
67522       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67523     } catch (std::out_of_range& e) {
67524       {
67525         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67526       };
67527     } catch (std::exception& e) {
67528       {
67529         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67530       };
67531     } catch (Dali::DaliException e) {
67532       {
67533         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67534       };
67535     } catch (...) {
67536       {
67537         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67538       };
67539     }
67540   }
67541
67542   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67543
67544   //argout typemap for const std::string&
67545
67546
67547   //argout typemap for const std::string&
67548
67549
67550   //argout typemap for const std::string&
67551
67552   return jresult;
67553 }
67554
67555
67556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67557   void * jresult ;
67558   Dali::Toolkit::Model3dView *result = 0 ;
67559
67560   {
67561     try {
67562       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
67563     } catch (std::out_of_range& e) {
67564       {
67565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67566       };
67567     } catch (std::exception& e) {
67568       {
67569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67570       };
67571     } catch (Dali::DaliException e) {
67572       {
67573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67574       };
67575     } catch (...) {
67576       {
67577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67578       };
67579     }
67580   }
67581
67582   jresult = (void *)result;
67583   return jresult;
67584 }
67585
67586
67587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67588   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67589
67590   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67591   {
67592     try {
67593       delete arg1;
67594     } catch (std::out_of_range& e) {
67595       {
67596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67597       };
67598     } catch (std::exception& e) {
67599       {
67600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67601       };
67602     } catch (Dali::DaliException e) {
67603       {
67604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67605       };
67606     } catch (...) {
67607       {
67608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67609       };
67610     }
67611   }
67612
67613 }
67614
67615
67616 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67617   void * jresult ;
67618   Dali::Toolkit::Model3dView *arg1 = 0 ;
67619   Dali::Toolkit::Model3dView *result = 0 ;
67620
67621   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67622   if (!arg1) {
67623     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67624     return 0;
67625   }
67626   {
67627     try {
67628       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67629     } catch (std::out_of_range& e) {
67630       {
67631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67632       };
67633     } catch (std::exception& e) {
67634       {
67635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67636       };
67637     } catch (Dali::DaliException e) {
67638       {
67639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67640       };
67641     } catch (...) {
67642       {
67643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67644       };
67645     }
67646   }
67647
67648   jresult = (void *)result;
67649   return jresult;
67650 }
67651
67652
67653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67654   void * jresult ;
67655   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67656   Dali::Toolkit::Model3dView *arg2 = 0 ;
67657   Dali::Toolkit::Model3dView *result = 0 ;
67658
67659   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67660   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67661   if (!arg2) {
67662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67663     return 0;
67664   }
67665   {
67666     try {
67667       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67668     } catch (std::out_of_range& e) {
67669       {
67670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67671       };
67672     } catch (std::exception& e) {
67673       {
67674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67675       };
67676     } catch (Dali::DaliException e) {
67677       {
67678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67679       };
67680     } catch (...) {
67681       {
67682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67683       };
67684     }
67685   }
67686
67687   jresult = (void *)result;
67688   return jresult;
67689 }
67690
67691
67692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67693   void * jresult ;
67694   Dali::BaseHandle arg1 ;
67695   Dali::BaseHandle *argp1 ;
67696   Dali::Toolkit::Model3dView result;
67697
67698   argp1 = (Dali::BaseHandle *)jarg1;
67699   if (!argp1) {
67700     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67701     return 0;
67702   }
67703   arg1 = *argp1;
67704   {
67705     try {
67706       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67707     } catch (std::out_of_range& e) {
67708       {
67709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67710       };
67711     } catch (std::exception& e) {
67712       {
67713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67714       };
67715     } catch (Dali::DaliException e) {
67716       {
67717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67718       };
67719     } catch (...) {
67720       {
67721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67722       };
67723     }
67724   }
67725
67726   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67727   return jresult;
67728 }
67729
67730
67731 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67732   int jresult ;
67733   int result;
67734
67735   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67736   jresult = (int)result;
67737   return jresult;
67738 }
67739
67740
67741 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67742   int jresult ;
67743   int result;
67744
67745   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67746   jresult = (int)result;
67747   return jresult;
67748 }
67749
67750
67751 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67752   int jresult ;
67753   int result;
67754
67755   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67756   jresult = (int)result;
67757   return jresult;
67758 }
67759
67760
67761 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67762   int jresult ;
67763   int result;
67764
67765   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67766   jresult = (int)result;
67767   return jresult;
67768 }
67769
67770
67771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67772   int jresult ;
67773   int result;
67774
67775   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67776   jresult = (int)result;
67777   return jresult;
67778 }
67779
67780
67781 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67782   int jresult ;
67783   int result;
67784
67785   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67786   jresult = (int)result;
67787   return jresult;
67788 }
67789
67790
67791 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67792   int jresult ;
67793   int result;
67794
67795   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67796   jresult = (int)result;
67797   return jresult;
67798 }
67799
67800
67801 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67802   int jresult ;
67803   int result;
67804
67805   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67806   jresult = (int)result;
67807   return jresult;
67808 }
67809
67810
67811 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67812   int jresult ;
67813   int result;
67814
67815   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67816   jresult = (int)result;
67817   return jresult;
67818 }
67819
67820
67821 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67822   void * jresult ;
67823   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67824
67825   {
67826     try {
67827       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67828     } catch (std::out_of_range& e) {
67829       {
67830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67831       };
67832     } catch (std::exception& e) {
67833       {
67834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67835       };
67836     } catch (Dali::DaliException e) {
67837       {
67838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67839       };
67840     } catch (...) {
67841       {
67842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67843       };
67844     }
67845   }
67846
67847   jresult = (void *)result;
67848   return jresult;
67849 }
67850
67851
67852 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67853   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67854
67855   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67856   {
67857     try {
67858       delete arg1;
67859     } catch (std::out_of_range& e) {
67860       {
67861         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67862       };
67863     } catch (std::exception& e) {
67864       {
67865         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67866       };
67867     } catch (Dali::DaliException e) {
67868       {
67869         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67870       };
67871     } catch (...) {
67872       {
67873         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67874       };
67875     }
67876   }
67877
67878 }
67879
67880
67881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67882   void * jresult ;
67883   Dali::Toolkit::ScrollBar *result = 0 ;
67884
67885   {
67886     try {
67887       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67888     } catch (std::out_of_range& e) {
67889       {
67890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67891       };
67892     } catch (std::exception& e) {
67893       {
67894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67895       };
67896     } catch (Dali::DaliException e) {
67897       {
67898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67899       };
67900     } catch (...) {
67901       {
67902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67903       };
67904     }
67905   }
67906
67907   jresult = (void *)result;
67908   return jresult;
67909 }
67910
67911
67912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67913   void * jresult ;
67914   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67915   Dali::Toolkit::ScrollBar *result = 0 ;
67916
67917   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67918   if (!arg1) {
67919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67920     return 0;
67921   }
67922   {
67923     try {
67924       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67925     } catch (std::out_of_range& e) {
67926       {
67927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67928       };
67929     } catch (std::exception& e) {
67930       {
67931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67932       };
67933     } catch (Dali::DaliException e) {
67934       {
67935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67936       };
67937     } catch (...) {
67938       {
67939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67940       };
67941     }
67942   }
67943
67944   jresult = (void *)result;
67945   return jresult;
67946 }
67947
67948
67949 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67950   void * jresult ;
67951   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67952   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67953   Dali::Toolkit::ScrollBar *result = 0 ;
67954
67955   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67956   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67957   if (!arg2) {
67958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67959     return 0;
67960   }
67961   {
67962     try {
67963       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67964     } catch (std::out_of_range& e) {
67965       {
67966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67967       };
67968     } catch (std::exception& e) {
67969       {
67970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67971       };
67972     } catch (Dali::DaliException e) {
67973       {
67974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67975       };
67976     } catch (...) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67979       };
67980     }
67981   }
67982
67983   jresult = (void *)result;
67984   return jresult;
67985 }
67986
67987
67988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67989   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67990
67991   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67992   {
67993     try {
67994       delete arg1;
67995     } catch (std::out_of_range& e) {
67996       {
67997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67998       };
67999     } catch (std::exception& e) {
68000       {
68001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68002       };
68003     } catch (Dali::DaliException e) {
68004       {
68005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68006       };
68007     } catch (...) {
68008       {
68009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68010       };
68011     }
68012   }
68013
68014 }
68015
68016
68017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
68018   void * jresult ;
68019   Dali::Toolkit::ScrollBar::Direction arg1 ;
68020   Dali::Toolkit::ScrollBar result;
68021
68022   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
68023   {
68024     try {
68025       result = Dali::Toolkit::ScrollBar::New(arg1);
68026     } catch (std::out_of_range& e) {
68027       {
68028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68029       };
68030     } catch (std::exception& e) {
68031       {
68032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68033       };
68034     } catch (Dali::DaliException e) {
68035       {
68036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68037       };
68038     } catch (...) {
68039       {
68040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68041       };
68042     }
68043   }
68044
68045   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68046   return jresult;
68047 }
68048
68049
68050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
68051   void * jresult ;
68052   Dali::Toolkit::ScrollBar result;
68053
68054   {
68055     try {
68056       result = Dali::Toolkit::ScrollBar::New();
68057     } catch (std::out_of_range& e) {
68058       {
68059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68060       };
68061     } catch (std::exception& e) {
68062       {
68063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68064       };
68065     } catch (Dali::DaliException e) {
68066       {
68067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68068       };
68069     } catch (...) {
68070       {
68071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68072       };
68073     }
68074   }
68075
68076   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68077   return jresult;
68078 }
68079
68080
68081 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
68082   void * jresult ;
68083   Dali::BaseHandle arg1 ;
68084   Dali::BaseHandle *argp1 ;
68085   Dali::Toolkit::ScrollBar result;
68086
68087   argp1 = (Dali::BaseHandle *)jarg1;
68088   if (!argp1) {
68089     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68090     return 0;
68091   }
68092   arg1 = *argp1;
68093   {
68094     try {
68095       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
68096     } catch (std::out_of_range& e) {
68097       {
68098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68099       };
68100     } catch (std::exception& e) {
68101       {
68102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68103       };
68104     } catch (Dali::DaliException e) {
68105       {
68106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68107       };
68108     } catch (...) {
68109       {
68110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68111       };
68112     }
68113   }
68114
68115   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
68116   return jresult;
68117 }
68118
68119
68120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
68121   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68122   Dali::Handle arg2 ;
68123   Dali::Property::Index arg3 ;
68124   Dali::Property::Index arg4 ;
68125   Dali::Property::Index arg5 ;
68126   Dali::Property::Index arg6 ;
68127   Dali::Handle *argp2 ;
68128
68129   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68130   argp2 = (Dali::Handle *)jarg2;
68131   if (!argp2) {
68132     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
68133     return ;
68134   }
68135   arg2 = *argp2;
68136   arg3 = (Dali::Property::Index)jarg3;
68137   arg4 = (Dali::Property::Index)jarg4;
68138   arg5 = (Dali::Property::Index)jarg5;
68139   arg6 = (Dali::Property::Index)jarg6;
68140   {
68141     try {
68142       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
68143     } catch (std::out_of_range& e) {
68144       {
68145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68146       };
68147     } catch (std::exception& e) {
68148       {
68149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68150       };
68151     } catch (Dali::DaliException e) {
68152       {
68153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68154       };
68155     } catch (...) {
68156       {
68157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68158       };
68159     }
68160   }
68161
68162 }
68163
68164
68165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
68166   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68167   Dali::Actor arg2 ;
68168   Dali::Actor *argp2 ;
68169
68170   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68171   argp2 = (Dali::Actor *)jarg2;
68172   if (!argp2) {
68173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
68174     return ;
68175   }
68176   arg2 = *argp2;
68177   {
68178     try {
68179       (arg1)->SetScrollIndicator(arg2);
68180     } catch (std::out_of_range& e) {
68181       {
68182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68183       };
68184     } catch (std::exception& e) {
68185       {
68186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68187       };
68188     } catch (Dali::DaliException e) {
68189       {
68190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68191       };
68192     } catch (...) {
68193       {
68194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68195       };
68196     }
68197   }
68198
68199 }
68200
68201
68202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
68203   void * jresult ;
68204   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68205   Dali::Actor result;
68206
68207   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68208   {
68209     try {
68210       result = (arg1)->GetScrollIndicator();
68211     } catch (std::out_of_range& e) {
68212       {
68213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68214       };
68215     } catch (std::exception& e) {
68216       {
68217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68218       };
68219     } catch (Dali::DaliException e) {
68220       {
68221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68222       };
68223     } catch (...) {
68224       {
68225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68226       };
68227     }
68228   }
68229
68230   jresult = new Dali::Actor((const Dali::Actor &)result);
68231   return jresult;
68232 }
68233
68234
68235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
68236   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68237   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
68238
68239   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68240   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
68241   if (!arg2) {
68242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
68243     return ;
68244   }
68245   {
68246     try {
68247       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
68248     } catch (std::out_of_range& e) {
68249       {
68250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68251       };
68252     } catch (std::exception& e) {
68253       {
68254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68255       };
68256     } catch (Dali::DaliException e) {
68257       {
68258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68259       };
68260     } catch (...) {
68261       {
68262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68263       };
68264     }
68265   }
68266
68267 }
68268
68269
68270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
68271   void * jresult ;
68272   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68273
68274   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68275   {
68276     try {
68277       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()));
68278     } catch (std::out_of_range& e) {
68279       {
68280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68281       };
68282     } catch (std::exception& e) {
68283       {
68284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68285       };
68286     } catch (...) {
68287       {
68288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68289       };
68290     }
68291   }
68292   return jresult;
68293 }
68294
68295
68296 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
68297   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68298   Dali::Toolkit::ScrollBar::Direction arg2 ;
68299
68300   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68301   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
68302   {
68303     try {
68304       (arg1)->SetScrollDirection(arg2);
68305     } catch (std::out_of_range& e) {
68306       {
68307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68308       };
68309     } catch (std::exception& e) {
68310       {
68311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68312       };
68313     } catch (Dali::DaliException e) {
68314       {
68315         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68316       };
68317     } catch (...) {
68318       {
68319         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68320       };
68321     }
68322   }
68323
68324 }
68325
68326
68327 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
68328   int jresult ;
68329   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68330   Dali::Toolkit::ScrollBar::Direction result;
68331
68332   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68333   {
68334     try {
68335       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
68336     } catch (std::out_of_range& e) {
68337       {
68338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68339       };
68340     } catch (std::exception& e) {
68341       {
68342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68343       };
68344     } catch (Dali::DaliException e) {
68345       {
68346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68347       };
68348     } catch (...) {
68349       {
68350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68351       };
68352     }
68353   }
68354
68355   jresult = (int)result;
68356   return jresult;
68357 }
68358
68359
68360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
68361   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68362   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
68363
68364   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68365   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
68366   {
68367     try {
68368       (arg1)->SetIndicatorHeightPolicy(arg2);
68369     } catch (std::out_of_range& e) {
68370       {
68371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68372       };
68373     } catch (std::exception& e) {
68374       {
68375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68376       };
68377     } catch (Dali::DaliException e) {
68378       {
68379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68380       };
68381     } catch (...) {
68382       {
68383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68384       };
68385     }
68386   }
68387
68388 }
68389
68390
68391 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
68392   int jresult ;
68393   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68394   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
68395
68396   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68397   {
68398     try {
68399       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
68400     } catch (std::out_of_range& e) {
68401       {
68402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68403       };
68404     } catch (std::exception& e) {
68405       {
68406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68407       };
68408     } catch (Dali::DaliException e) {
68409       {
68410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68411       };
68412     } catch (...) {
68413       {
68414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68415       };
68416     }
68417   }
68418
68419   jresult = (int)result;
68420   return jresult;
68421 }
68422
68423
68424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
68425   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68426   float arg2 ;
68427
68428   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68429   arg2 = (float)jarg2;
68430   {
68431     try {
68432       (arg1)->SetIndicatorFixedHeight(arg2);
68433     } catch (std::out_of_range& e) {
68434       {
68435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68436       };
68437     } catch (std::exception& e) {
68438       {
68439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68440       };
68441     } catch (Dali::DaliException e) {
68442       {
68443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68444       };
68445     } catch (...) {
68446       {
68447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68448       };
68449     }
68450   }
68451
68452 }
68453
68454
68455 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
68456   float jresult ;
68457   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68458   float result;
68459
68460   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68461   {
68462     try {
68463       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
68464     } catch (std::out_of_range& e) {
68465       {
68466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68467       };
68468     } catch (std::exception& e) {
68469       {
68470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68471       };
68472     } catch (Dali::DaliException e) {
68473       {
68474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68475       };
68476     } catch (...) {
68477       {
68478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68479       };
68480     }
68481   }
68482
68483   jresult = result;
68484   return jresult;
68485 }
68486
68487
68488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
68489   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68490   float arg2 ;
68491
68492   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68493   arg2 = (float)jarg2;
68494   {
68495     try {
68496       (arg1)->SetIndicatorShowDuration(arg2);
68497     } catch (std::out_of_range& e) {
68498       {
68499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68500       };
68501     } catch (std::exception& e) {
68502       {
68503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68504       };
68505     } catch (Dali::DaliException e) {
68506       {
68507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68508       };
68509     } catch (...) {
68510       {
68511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68512       };
68513     }
68514   }
68515
68516 }
68517
68518
68519 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68520   float jresult ;
68521   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68522   float result;
68523
68524   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68525   {
68526     try {
68527       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68528     } catch (std::out_of_range& e) {
68529       {
68530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68531       };
68532     } catch (std::exception& e) {
68533       {
68534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68535       };
68536     } catch (Dali::DaliException e) {
68537       {
68538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68539       };
68540     } catch (...) {
68541       {
68542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68543       };
68544     }
68545   }
68546
68547   jresult = result;
68548   return jresult;
68549 }
68550
68551
68552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68553   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68554   float arg2 ;
68555
68556   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68557   arg2 = (float)jarg2;
68558   {
68559     try {
68560       (arg1)->SetIndicatorHideDuration(arg2);
68561     } catch (std::out_of_range& e) {
68562       {
68563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68564       };
68565     } catch (std::exception& e) {
68566       {
68567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68568       };
68569     } catch (Dali::DaliException e) {
68570       {
68571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68572       };
68573     } catch (...) {
68574       {
68575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68576       };
68577     }
68578   }
68579
68580 }
68581
68582
68583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68584   float jresult ;
68585   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68586   float result;
68587
68588   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68589   {
68590     try {
68591       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
68592     } catch (std::out_of_range& e) {
68593       {
68594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68595       };
68596     } catch (std::exception& e) {
68597       {
68598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68599       };
68600     } catch (Dali::DaliException e) {
68601       {
68602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68603       };
68604     } catch (...) {
68605       {
68606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68607       };
68608     }
68609   }
68610
68611   jresult = result;
68612   return jresult;
68613 }
68614
68615
68616 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68617   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68618
68619   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68620   {
68621     try {
68622       (arg1)->ShowIndicator();
68623     } catch (std::out_of_range& e) {
68624       {
68625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68626       };
68627     } catch (std::exception& e) {
68628       {
68629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68630       };
68631     } catch (Dali::DaliException e) {
68632       {
68633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68634       };
68635     } catch (...) {
68636       {
68637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68638       };
68639     }
68640   }
68641
68642 }
68643
68644
68645 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68646   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68647
68648   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68649   {
68650     try {
68651       (arg1)->HideIndicator();
68652     } catch (std::out_of_range& e) {
68653       {
68654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68655       };
68656     } catch (std::exception& e) {
68657       {
68658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68659       };
68660     } catch (Dali::DaliException e) {
68661       {
68662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68663       };
68664     } catch (...) {
68665       {
68666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68667       };
68668     }
68669   }
68670
68671 }
68672
68673
68674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68675   void * jresult ;
68676   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68677   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68678
68679   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68680   {
68681     try {
68682       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68683     } catch (std::out_of_range& e) {
68684       {
68685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68686       };
68687     } catch (std::exception& e) {
68688       {
68689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68690       };
68691     } catch (Dali::DaliException e) {
68692       {
68693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68694       };
68695     } catch (...) {
68696       {
68697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68698       };
68699     }
68700   }
68701
68702   jresult = (void *)result;
68703   return jresult;
68704 }
68705
68706
68707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68708   void * jresult ;
68709   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68710   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68711
68712   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68713   {
68714     try {
68715       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68716     } catch (std::out_of_range& e) {
68717       {
68718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68719       };
68720     } catch (std::exception& e) {
68721       {
68722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68723       };
68724     } catch (Dali::DaliException e) {
68725       {
68726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68727       };
68728     } catch (...) {
68729       {
68730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68731       };
68732     }
68733   }
68734
68735   jresult = (void *)result;
68736   return jresult;
68737 }
68738
68739
68740 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68741   int jresult ;
68742   int result;
68743
68744   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68745   jresult = (int)result;
68746   return jresult;
68747 }
68748
68749
68750 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68751   int jresult ;
68752   int result;
68753
68754   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68755   jresult = (int)result;
68756   return jresult;
68757 }
68758
68759
68760 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68761   int jresult ;
68762   int result;
68763
68764   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68765   jresult = (int)result;
68766   return jresult;
68767 }
68768
68769
68770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68771   int jresult ;
68772   int result;
68773
68774   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68775   jresult = (int)result;
68776   return jresult;
68777 }
68778
68779
68780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68781   int jresult ;
68782   int result;
68783
68784   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68785   jresult = (int)result;
68786   return jresult;
68787 }
68788
68789
68790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68791   int jresult ;
68792   int result;
68793
68794   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68795   jresult = (int)result;
68796   return jresult;
68797 }
68798
68799
68800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68801   int jresult ;
68802   int result;
68803
68804   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68805   jresult = (int)result;
68806   return jresult;
68807 }
68808
68809
68810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68811   int jresult ;
68812   int result;
68813
68814   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68815   jresult = (int)result;
68816   return jresult;
68817 }
68818
68819
68820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68821   int jresult ;
68822   int result;
68823
68824   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68825   jresult = (int)result;
68826   return jresult;
68827 }
68828
68829
68830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68831   int jresult ;
68832   int result;
68833
68834   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68835   jresult = (int)result;
68836   return jresult;
68837 }
68838
68839
68840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68841   int jresult ;
68842   int result;
68843
68844   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68845   jresult = (int)result;
68846   return jresult;
68847 }
68848
68849
68850 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68851   int jresult ;
68852   int result;
68853
68854   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68855   jresult = (int)result;
68856   return jresult;
68857 }
68858
68859
68860 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68861   int jresult ;
68862   int result;
68863
68864   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68865   jresult = (int)result;
68866   return jresult;
68867 }
68868
68869
68870 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68871   int jresult ;
68872   int result;
68873
68874   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68875   jresult = (int)result;
68876   return jresult;
68877 }
68878
68879
68880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68881   void * jresult ;
68882   Dali::Toolkit::Scrollable::Property *result = 0 ;
68883
68884   {
68885     try {
68886       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68887     } catch (std::out_of_range& e) {
68888       {
68889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68890       };
68891     } catch (std::exception& e) {
68892       {
68893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68894       };
68895     } catch (Dali::DaliException e) {
68896       {
68897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68898       };
68899     } catch (...) {
68900       {
68901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68902       };
68903     }
68904   }
68905
68906   jresult = (void *)result;
68907   return jresult;
68908 }
68909
68910
68911 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68912   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68913
68914   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68915   {
68916     try {
68917       delete arg1;
68918     } catch (std::out_of_range& e) {
68919       {
68920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68921       };
68922     } catch (std::exception& e) {
68923       {
68924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68925       };
68926     } catch (Dali::DaliException e) {
68927       {
68928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68929       };
68930     } catch (...) {
68931       {
68932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68933       };
68934     }
68935   }
68936
68937 }
68938
68939
68940 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68941   void * jresult ;
68942   Dali::Toolkit::Scrollable *result = 0 ;
68943
68944   {
68945     try {
68946       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68947     } catch (std::out_of_range& e) {
68948       {
68949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68950       };
68951     } catch (std::exception& e) {
68952       {
68953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68954       };
68955     } catch (Dali::DaliException e) {
68956       {
68957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68958       };
68959     } catch (...) {
68960       {
68961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68962       };
68963     }
68964   }
68965
68966   jresult = (void *)result;
68967   return jresult;
68968 }
68969
68970
68971 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68972   void * jresult ;
68973   Dali::Toolkit::Scrollable *arg1 = 0 ;
68974   Dali::Toolkit::Scrollable *result = 0 ;
68975
68976   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68977   if (!arg1) {
68978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68979     return 0;
68980   }
68981   {
68982     try {
68983       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68984     } catch (std::out_of_range& e) {
68985       {
68986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68987       };
68988     } catch (std::exception& e) {
68989       {
68990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68991       };
68992     } catch (Dali::DaliException e) {
68993       {
68994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68995       };
68996     } catch (...) {
68997       {
68998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68999       };
69000     }
69001   }
69002
69003   jresult = (void *)result;
69004   return jresult;
69005 }
69006
69007
69008 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
69009   void * jresult ;
69010   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69011   Dali::Toolkit::Scrollable *arg2 = 0 ;
69012   Dali::Toolkit::Scrollable *result = 0 ;
69013
69014   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69015   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
69016   if (!arg2) {
69017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
69018     return 0;
69019   }
69020   {
69021     try {
69022       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
69023     } catch (std::out_of_range& e) {
69024       {
69025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69026       };
69027     } catch (std::exception& e) {
69028       {
69029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69030       };
69031     } catch (Dali::DaliException e) {
69032       {
69033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69034       };
69035     } catch (...) {
69036       {
69037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69038       };
69039     }
69040   }
69041
69042   jresult = (void *)result;
69043   return jresult;
69044 }
69045
69046
69047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
69048   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69049
69050   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69051   {
69052     try {
69053       delete arg1;
69054     } catch (std::out_of_range& e) {
69055       {
69056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69057       };
69058     } catch (std::exception& e) {
69059       {
69060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69061       };
69062     } catch (Dali::DaliException e) {
69063       {
69064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69065       };
69066     } catch (...) {
69067       {
69068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69069       };
69070     }
69071   }
69072
69073 }
69074
69075
69076 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
69077   void * jresult ;
69078   Dali::BaseHandle arg1 ;
69079   Dali::BaseHandle *argp1 ;
69080   Dali::Toolkit::Scrollable result;
69081
69082   argp1 = (Dali::BaseHandle *)jarg1;
69083   if (!argp1) {
69084     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
69085     return 0;
69086   }
69087   arg1 = *argp1;
69088   {
69089     try {
69090       result = Dali::Toolkit::Scrollable::DownCast(arg1);
69091     } catch (std::out_of_range& e) {
69092       {
69093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69094       };
69095     } catch (std::exception& e) {
69096       {
69097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69098       };
69099     } catch (Dali::DaliException e) {
69100       {
69101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69102       };
69103     } catch (...) {
69104       {
69105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69106       };
69107     }
69108   }
69109
69110   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
69111   return jresult;
69112 }
69113
69114
69115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
69116   unsigned int jresult ;
69117   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69118   bool result;
69119
69120   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69121   {
69122     try {
69123       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
69124     } catch (std::out_of_range& e) {
69125       {
69126         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69127       };
69128     } catch (std::exception& e) {
69129       {
69130         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69131       };
69132     } catch (Dali::DaliException e) {
69133       {
69134         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69135       };
69136     } catch (...) {
69137       {
69138         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69139       };
69140     }
69141   }
69142
69143   jresult = result;
69144   return jresult;
69145 }
69146
69147
69148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
69149   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69150   bool arg2 ;
69151
69152   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69153   arg2 = jarg2 ? true : false;
69154   {
69155     try {
69156       (arg1)->SetOvershootEnabled(arg2);
69157     } catch (std::out_of_range& e) {
69158       {
69159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69160       };
69161     } catch (std::exception& e) {
69162       {
69163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69164       };
69165     } catch (Dali::DaliException e) {
69166       {
69167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69168       };
69169     } catch (...) {
69170       {
69171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69172       };
69173     }
69174   }
69175
69176 }
69177
69178
69179 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
69180   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69181   Dali::Vector4 *arg2 = 0 ;
69182
69183   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69184   arg2 = (Dali::Vector4 *)jarg2;
69185   if (!arg2) {
69186     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
69187     return ;
69188   }
69189   {
69190     try {
69191       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
69192     } catch (std::out_of_range& e) {
69193       {
69194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69195       };
69196     } catch (std::exception& e) {
69197       {
69198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69199       };
69200     } catch (Dali::DaliException e) {
69201       {
69202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69203       };
69204     } catch (...) {
69205       {
69206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69207       };
69208     }
69209   }
69210
69211 }
69212
69213
69214 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
69215   void * jresult ;
69216   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69217   Dali::Vector4 result;
69218
69219   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69220   {
69221     try {
69222       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
69223     } catch (std::out_of_range& e) {
69224       {
69225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69226       };
69227     } catch (std::exception& e) {
69228       {
69229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69230       };
69231     } catch (Dali::DaliException e) {
69232       {
69233         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69234       };
69235     } catch (...) {
69236       {
69237         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69238       };
69239     }
69240   }
69241
69242   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
69243   return jresult;
69244 }
69245
69246
69247 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
69248   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69249   float arg2 ;
69250
69251   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69252   arg2 = (float)jarg2;
69253   {
69254     try {
69255       (arg1)->SetOvershootAnimationSpeed(arg2);
69256     } catch (std::out_of_range& e) {
69257       {
69258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69259       };
69260     } catch (std::exception& e) {
69261       {
69262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69263       };
69264     } catch (Dali::DaliException e) {
69265       {
69266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69267       };
69268     } catch (...) {
69269       {
69270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69271       };
69272     }
69273   }
69274
69275 }
69276
69277
69278 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
69279   float jresult ;
69280   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69281   float result;
69282
69283   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69284   {
69285     try {
69286       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
69287     } catch (std::out_of_range& e) {
69288       {
69289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69290       };
69291     } catch (std::exception& e) {
69292       {
69293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69294       };
69295     } catch (Dali::DaliException e) {
69296       {
69297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69298       };
69299     } catch (...) {
69300       {
69301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69302       };
69303     }
69304   }
69305
69306   jresult = result;
69307   return jresult;
69308 }
69309
69310
69311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
69312   void * jresult ;
69313   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69314   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
69315
69316   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69317   {
69318     try {
69319       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
69320     } catch (std::out_of_range& e) {
69321       {
69322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69323       };
69324     } catch (std::exception& e) {
69325       {
69326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69327       };
69328     } catch (Dali::DaliException e) {
69329       {
69330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69331       };
69332     } catch (...) {
69333       {
69334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69335       };
69336     }
69337   }
69338
69339   jresult = (void *)result;
69340   return jresult;
69341 }
69342
69343
69344 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
69345   void * jresult ;
69346   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69347   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
69348
69349   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69350   {
69351     try {
69352       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
69353     } catch (std::out_of_range& e) {
69354       {
69355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69356       };
69357     } catch (std::exception& e) {
69358       {
69359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69360       };
69361     } catch (Dali::DaliException e) {
69362       {
69363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69364       };
69365     } catch (...) {
69366       {
69367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69368       };
69369     }
69370   }
69371
69372   jresult = (void *)result;
69373   return jresult;
69374 }
69375
69376
69377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
69378   void * jresult ;
69379   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
69380   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
69381
69382   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
69383   {
69384     try {
69385       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
69386     } catch (std::out_of_range& e) {
69387       {
69388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69389       };
69390     } catch (std::exception& e) {
69391       {
69392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69393       };
69394     } catch (Dali::DaliException e) {
69395       {
69396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69397       };
69398     } catch (...) {
69399       {
69400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69401       };
69402     }
69403   }
69404
69405   jresult = (void *)result;
69406   return jresult;
69407 }
69408
69409
69410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
69411   unsigned int jresult ;
69412   Dali::Toolkit::ControlOrientation::Type arg1 ;
69413   bool result;
69414
69415   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69416   {
69417     try {
69418       result = (bool)Dali::Toolkit::IsVertical(arg1);
69419     } catch (std::out_of_range& e) {
69420       {
69421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69422       };
69423     } catch (std::exception& e) {
69424       {
69425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69426       };
69427     } catch (Dali::DaliException e) {
69428       {
69429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69430       };
69431     } catch (...) {
69432       {
69433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69434       };
69435     }
69436   }
69437
69438   jresult = result;
69439   return jresult;
69440 }
69441
69442
69443 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
69444   unsigned int jresult ;
69445   Dali::Toolkit::ControlOrientation::Type arg1 ;
69446   bool result;
69447
69448   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
69449   {
69450     try {
69451       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
69452     } catch (std::out_of_range& e) {
69453       {
69454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69455       };
69456     } catch (std::exception& e) {
69457       {
69458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69459       };
69460     } catch (Dali::DaliException e) {
69461       {
69462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69463       };
69464     } catch (...) {
69465       {
69466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69467       };
69468     }
69469   }
69470
69471   jresult = result;
69472   return jresult;
69473 }
69474
69475
69476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
69477   void * jresult ;
69478   unsigned int arg1 ;
69479   unsigned int arg2 ;
69480   Dali::Toolkit::ItemRange *result = 0 ;
69481
69482   arg1 = (unsigned int)jarg1;
69483   arg2 = (unsigned int)jarg2;
69484   {
69485     try {
69486       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
69487     } catch (std::out_of_range& e) {
69488       {
69489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69490       };
69491     } catch (std::exception& e) {
69492       {
69493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69494       };
69495     } catch (Dali::DaliException e) {
69496       {
69497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69498       };
69499     } catch (...) {
69500       {
69501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69502       };
69503     }
69504   }
69505
69506   jresult = (void *)result;
69507   return jresult;
69508 }
69509
69510
69511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69512   void * jresult ;
69513   Dali::Toolkit::ItemRange *arg1 = 0 ;
69514   Dali::Toolkit::ItemRange *result = 0 ;
69515
69516   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69517   if (!arg1) {
69518     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69519     return 0;
69520   }
69521   {
69522     try {
69523       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69524     } catch (std::out_of_range& e) {
69525       {
69526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69527       };
69528     } catch (std::exception& e) {
69529       {
69530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69531       };
69532     } catch (Dali::DaliException e) {
69533       {
69534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69535       };
69536     } catch (...) {
69537       {
69538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69539       };
69540     }
69541   }
69542
69543   jresult = (void *)result;
69544   return jresult;
69545 }
69546
69547
69548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69549   void * jresult ;
69550   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69551   Dali::Toolkit::ItemRange *arg2 = 0 ;
69552   Dali::Toolkit::ItemRange *result = 0 ;
69553
69554   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69555   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69556   if (!arg2) {
69557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69558     return 0;
69559   }
69560   {
69561     try {
69562       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69563     } catch (std::out_of_range& e) {
69564       {
69565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69566       };
69567     } catch (std::exception& e) {
69568       {
69569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69570       };
69571     } catch (Dali::DaliException e) {
69572       {
69573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69574       };
69575     } catch (...) {
69576       {
69577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69578       };
69579     }
69580   }
69581
69582   jresult = (void *)result;
69583   return jresult;
69584 }
69585
69586
69587 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69588   unsigned int jresult ;
69589   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69590   unsigned int arg2 ;
69591   bool result;
69592
69593   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69594   arg2 = (unsigned int)jarg2;
69595   {
69596     try {
69597       result = (bool)(arg1)->Within(arg2);
69598     } catch (std::out_of_range& e) {
69599       {
69600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69601       };
69602     } catch (std::exception& e) {
69603       {
69604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69605       };
69606     } catch (Dali::DaliException e) {
69607       {
69608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69609       };
69610     } catch (...) {
69611       {
69612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69613       };
69614     }
69615   }
69616
69617   jresult = result;
69618   return jresult;
69619 }
69620
69621
69622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69623   void * jresult ;
69624   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69625   Dali::Toolkit::ItemRange *arg2 = 0 ;
69626   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69627
69628   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69629   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69630   if (!arg2) {
69631     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69632     return 0;
69633   }
69634   {
69635     try {
69636       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69637     } catch (std::out_of_range& e) {
69638       {
69639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69640       };
69641     } catch (std::exception& e) {
69642       {
69643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69644       };
69645     } catch (Dali::DaliException e) {
69646       {
69647         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69648       };
69649     } catch (...) {
69650       {
69651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69652       };
69653     }
69654   }
69655
69656   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69657   return jresult;
69658 }
69659
69660
69661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69662   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69663   unsigned int arg2 ;
69664
69665   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69666   arg2 = (unsigned int)jarg2;
69667   if (arg1) (arg1)->begin = arg2;
69668 }
69669
69670
69671 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69672   unsigned int jresult ;
69673   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69674   unsigned int result;
69675
69676   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69677   result = (unsigned int) ((arg1)->begin);
69678   jresult = result;
69679   return jresult;
69680 }
69681
69682
69683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69684   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69685   unsigned int arg2 ;
69686
69687   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69688   arg2 = (unsigned int)jarg2;
69689   if (arg1) (arg1)->end = arg2;
69690 }
69691
69692
69693 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69694   unsigned int jresult ;
69695   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69696   unsigned int result;
69697
69698   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69699   result = (unsigned int) ((arg1)->end);
69700   jresult = result;
69701   return jresult;
69702 }
69703
69704
69705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69706   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69707
69708   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69709   {
69710     try {
69711       delete arg1;
69712     } catch (std::out_of_range& e) {
69713       {
69714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69715       };
69716     } catch (std::exception& e) {
69717       {
69718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69719       };
69720     } catch (Dali::DaliException e) {
69721       {
69722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69723       };
69724     } catch (...) {
69725       {
69726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69727       };
69728     }
69729   }
69730
69731 }
69732
69733
69734 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69735   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69736
69737   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69738   {
69739     try {
69740       delete arg1;
69741     } catch (std::out_of_range& e) {
69742       {
69743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69744       };
69745     } catch (std::exception& e) {
69746       {
69747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69748       };
69749     } catch (Dali::DaliException e) {
69750       {
69751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69752       };
69753     } catch (...) {
69754       {
69755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69756       };
69757     }
69758   }
69759
69760 }
69761
69762
69763 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69764   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69765   Dali::Toolkit::ControlOrientation::Type arg2 ;
69766
69767   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69768   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69769   {
69770     try {
69771       (arg1)->SetOrientation(arg2);
69772     } catch (std::out_of_range& e) {
69773       {
69774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69775       };
69776     } catch (std::exception& e) {
69777       {
69778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69779       };
69780     } catch (Dali::DaliException e) {
69781       {
69782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69783       };
69784     } catch (...) {
69785       {
69786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69787       };
69788     }
69789   }
69790
69791 }
69792
69793
69794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69795   int jresult ;
69796   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69797   Dali::Toolkit::ControlOrientation::Type result;
69798
69799   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69800   {
69801     try {
69802       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69803     } catch (std::out_of_range& e) {
69804       {
69805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69806       };
69807     } catch (std::exception& e) {
69808       {
69809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69810       };
69811     } catch (Dali::DaliException e) {
69812       {
69813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69814       };
69815     } catch (...) {
69816       {
69817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69818       };
69819     }
69820   }
69821
69822   jresult = (int)result;
69823   return jresult;
69824 }
69825
69826
69827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69828   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69829   Dali::Property::Map *arg2 = 0 ;
69830
69831   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69832   arg2 = (Dali::Property::Map *)jarg2;
69833   if (!arg2) {
69834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69835     return ;
69836   }
69837   {
69838     try {
69839       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69840     } catch (std::out_of_range& e) {
69841       {
69842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69843       };
69844     } catch (std::exception& e) {
69845       {
69846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69847       };
69848     } catch (Dali::DaliException e) {
69849       {
69850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69851       };
69852     } catch (...) {
69853       {
69854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69855       };
69856     }
69857   }
69858
69859 }
69860
69861
69862 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69863   void * jresult ;
69864   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69865   Dali::Property::Map result;
69866
69867   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69868   {
69869     try {
69870       result = (arg1)->GetLayoutProperties();
69871     } catch (std::out_of_range& e) {
69872       {
69873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69874       };
69875     } catch (std::exception& e) {
69876       {
69877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69878       };
69879     } catch (Dali::DaliException e) {
69880       {
69881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69882       };
69883     } catch (...) {
69884       {
69885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69886       };
69887     }
69888   }
69889
69890   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69891   return jresult;
69892 }
69893
69894
69895 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69896   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69897   unsigned int arg2 ;
69898   Dali::Vector3 *arg3 = 0 ;
69899   Dali::Vector3 *arg4 = 0 ;
69900
69901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69902   arg2 = (unsigned int)jarg2;
69903   arg3 = (Dali::Vector3 *)jarg3;
69904   if (!arg3) {
69905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69906     return ;
69907   }
69908   arg4 = (Dali::Vector3 *)jarg4;
69909   if (!arg4) {
69910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69911     return ;
69912   }
69913   {
69914     try {
69915       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69916     } catch (std::out_of_range& e) {
69917       {
69918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69919       };
69920     } catch (std::exception& e) {
69921       {
69922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69923       };
69924     } catch (Dali::DaliException e) {
69925       {
69926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69927       };
69928     } catch (...) {
69929       {
69930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69931       };
69932     }
69933   }
69934
69935 }
69936
69937
69938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69939   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69940   Dali::Vector3 *arg2 = 0 ;
69941
69942   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69943   arg2 = (Dali::Vector3 *)jarg2;
69944   if (!arg2) {
69945     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69946     return ;
69947   }
69948   {
69949     try {
69950       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69951     } catch (std::out_of_range& e) {
69952       {
69953         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69954       };
69955     } catch (std::exception& e) {
69956       {
69957         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69958       };
69959     } catch (Dali::DaliException e) {
69960       {
69961         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69962       };
69963     } catch (...) {
69964       {
69965         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69966       };
69967     }
69968   }
69969
69970 }
69971
69972
69973 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69974   float jresult ;
69975   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69976   unsigned int arg2 ;
69977   Dali::Vector3 arg3 ;
69978   Dali::Vector3 *argp3 ;
69979   float result;
69980
69981   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69982   arg2 = (unsigned int)jarg2;
69983   argp3 = (Dali::Vector3 *)jarg3;
69984   if (!argp3) {
69985     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69986     return 0;
69987   }
69988   arg3 = *argp3;
69989   {
69990     try {
69991       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69992     } catch (std::out_of_range& e) {
69993       {
69994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69995       };
69996     } catch (std::exception& e) {
69997       {
69998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69999       };
70000     } catch (Dali::DaliException e) {
70001       {
70002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70003       };
70004     } catch (...) {
70005       {
70006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70007       };
70008     }
70009   }
70010
70011   jresult = result;
70012   return jresult;
70013 }
70014
70015
70016 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
70017   float jresult ;
70018   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70019   float arg2 ;
70020   float result;
70021
70022   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70023   arg2 = (float)jarg2;
70024   {
70025     try {
70026       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
70027     } catch (std::out_of_range& e) {
70028       {
70029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70030       };
70031     } catch (std::exception& e) {
70032       {
70033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70034       };
70035     } catch (Dali::DaliException e) {
70036       {
70037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70038       };
70039     } catch (...) {
70040       {
70041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70042       };
70043     }
70044   }
70045
70046   jresult = result;
70047   return jresult;
70048 }
70049
70050
70051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
70052   float jresult ;
70053   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70054   unsigned int arg2 ;
70055   float result;
70056
70057   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70058   arg2 = (unsigned int)jarg2;
70059   {
70060     try {
70061       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
70062     } catch (std::out_of_range& e) {
70063       {
70064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70065       };
70066     } catch (std::exception& e) {
70067       {
70068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70069       };
70070     } catch (Dali::DaliException e) {
70071       {
70072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70073       };
70074     } catch (...) {
70075       {
70076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70077       };
70078     }
70079   }
70080
70081   jresult = result;
70082   return jresult;
70083 }
70084
70085
70086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
70087   void * jresult ;
70088   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70089   float arg2 ;
70090   Dali::Vector3 arg3 ;
70091   Dali::Vector3 *argp3 ;
70092   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
70093
70094   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70095   arg2 = (float)jarg2;
70096   argp3 = (Dali::Vector3 *)jarg3;
70097   if (!argp3) {
70098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70099     return 0;
70100   }
70101   arg3 = *argp3;
70102   {
70103     try {
70104       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
70105     } catch (std::out_of_range& e) {
70106       {
70107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70108       };
70109     } catch (std::exception& e) {
70110       {
70111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70112       };
70113     } catch (Dali::DaliException e) {
70114       {
70115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70116       };
70117     } catch (...) {
70118       {
70119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70120       };
70121     }
70122   }
70123
70124   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
70125   return jresult;
70126 }
70127
70128
70129 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70130   float jresult ;
70131   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70132   int arg2 ;
70133   float arg3 ;
70134   Dali::Vector3 *arg4 = 0 ;
70135   float result;
70136
70137   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70138   arg2 = (int)jarg2;
70139   arg3 = (float)jarg3;
70140   arg4 = (Dali::Vector3 *)jarg4;
70141   if (!arg4) {
70142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70143     return 0;
70144   }
70145   {
70146     try {
70147       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70148     } catch (std::out_of_range& e) {
70149       {
70150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70151       };
70152     } catch (std::exception& e) {
70153       {
70154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70155       };
70156     } catch (Dali::DaliException e) {
70157       {
70158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70159       };
70160     } catch (...) {
70161       {
70162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70163       };
70164     }
70165   }
70166
70167   jresult = result;
70168   return jresult;
70169 }
70170
70171
70172 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
70173   unsigned int jresult ;
70174   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70175   Dali::Vector3 arg2 ;
70176   Dali::Vector3 *argp2 ;
70177   unsigned int result;
70178
70179   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70180   argp2 = (Dali::Vector3 *)jarg2;
70181   if (!argp2) {
70182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70183     return 0;
70184   }
70185   arg2 = *argp2;
70186   {
70187     try {
70188       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
70189     } catch (std::out_of_range& e) {
70190       {
70191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70192       };
70193     } catch (std::exception& e) {
70194       {
70195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70196       };
70197     } catch (Dali::DaliException e) {
70198       {
70199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70200       };
70201     } catch (...) {
70202       {
70203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70204       };
70205     }
70206   }
70207
70208   jresult = result;
70209   return jresult;
70210 }
70211
70212
70213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
70214   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70215   unsigned int arg2 ;
70216   Dali::Vector3 *arg3 = 0 ;
70217   Dali::Vector3 *arg4 = 0 ;
70218
70219   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70220   arg2 = (unsigned int)jarg2;
70221   arg3 = (Dali::Vector3 *)jarg3;
70222   if (!arg3) {
70223     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70224     return ;
70225   }
70226   arg4 = (Dali::Vector3 *)jarg4;
70227   if (!arg4) {
70228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
70229     return ;
70230   }
70231   {
70232     try {
70233       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
70234     } catch (std::out_of_range& e) {
70235       {
70236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70237       };
70238     } catch (std::exception& e) {
70239       {
70240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70241       };
70242     } catch (Dali::DaliException e) {
70243       {
70244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70245       };
70246     } catch (...) {
70247       {
70248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70249       };
70250     }
70251   }
70252
70253 }
70254
70255
70256 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
70257   void * jresult ;
70258   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70259   Dali::Degree result;
70260
70261   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70262   {
70263     try {
70264       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
70265     } catch (std::out_of_range& e) {
70266       {
70267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70268       };
70269     } catch (std::exception& e) {
70270       {
70271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70272       };
70273     } catch (Dali::DaliException e) {
70274       {
70275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70276       };
70277     } catch (...) {
70278       {
70279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70280       };
70281     }
70282   }
70283
70284   jresult = new Dali::Degree((const Dali::Degree &)result);
70285   return jresult;
70286 }
70287
70288
70289 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
70290   float jresult ;
70291   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70292   float result;
70293
70294   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70295   {
70296     try {
70297       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
70298     } catch (std::out_of_range& e) {
70299       {
70300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70301       };
70302     } catch (std::exception& e) {
70303       {
70304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70305       };
70306     } catch (Dali::DaliException e) {
70307       {
70308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70309       };
70310     } catch (...) {
70311       {
70312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70313       };
70314     }
70315   }
70316
70317   jresult = result;
70318   return jresult;
70319 }
70320
70321
70322 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
70323   float jresult ;
70324   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70325   float result;
70326
70327   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70328   {
70329     try {
70330       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
70331     } catch (std::out_of_range& e) {
70332       {
70333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70334       };
70335     } catch (std::exception& e) {
70336       {
70337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70338       };
70339     } catch (Dali::DaliException e) {
70340       {
70341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70342       };
70343     } catch (...) {
70344       {
70345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70346       };
70347     }
70348   }
70349
70350   jresult = result;
70351   return jresult;
70352 }
70353
70354
70355 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
70356   float jresult ;
70357   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70358   float result;
70359
70360   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70361   {
70362     try {
70363       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
70364     } catch (std::out_of_range& e) {
70365       {
70366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70367       };
70368     } catch (std::exception& e) {
70369       {
70370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70371       };
70372     } catch (Dali::DaliException e) {
70373       {
70374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70375       };
70376     } catch (...) {
70377       {
70378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70379       };
70380     }
70381   }
70382
70383   jresult = result;
70384   return jresult;
70385 }
70386
70387
70388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
70389   int jresult ;
70390   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70391   int arg2 ;
70392   int arg3 ;
70393   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
70394   bool arg5 ;
70395   int result;
70396
70397   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70398   arg2 = (int)jarg2;
70399   arg3 = (int)jarg3;
70400   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
70401   arg5 = jarg5 ? true : false;
70402   {
70403     try {
70404       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
70405     } catch (std::out_of_range& e) {
70406       {
70407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70408       };
70409     } catch (std::exception& e) {
70410       {
70411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70412       };
70413     } catch (Dali::DaliException e) {
70414       {
70415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70416       };
70417     } catch (...) {
70418       {
70419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70420       };
70421     }
70422   }
70423
70424   jresult = result;
70425   return jresult;
70426 }
70427
70428
70429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
70430   float jresult ;
70431   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70432   float result;
70433
70434   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70435   {
70436     try {
70437       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
70438     } catch (std::out_of_range& e) {
70439       {
70440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70441       };
70442     } catch (std::exception& e) {
70443       {
70444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70445       };
70446     } catch (Dali::DaliException e) {
70447       {
70448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70449       };
70450     } catch (...) {
70451       {
70452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70453       };
70454     }
70455   }
70456
70457   jresult = result;
70458   return jresult;
70459 }
70460
70461
70462 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
70463   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70464   Dali::Actor *arg2 = 0 ;
70465   int arg3 ;
70466   Dali::Vector3 *arg4 = 0 ;
70467   Dali::Actor *arg5 = 0 ;
70468
70469   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70470   arg2 = (Dali::Actor *)jarg2;
70471   if (!arg2) {
70472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
70473     return ;
70474   }
70475   arg3 = (int)jarg3;
70476   arg4 = (Dali::Vector3 *)jarg4;
70477   if (!arg4) {
70478     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70479     return ;
70480   }
70481   arg5 = (Dali::Actor *)jarg5;
70482   if (!arg5) {
70483     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
70484     return ;
70485   }
70486   {
70487     try {
70488       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
70489     } catch (std::out_of_range& e) {
70490       {
70491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70492       };
70493     } catch (std::exception& e) {
70494       {
70495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70496       };
70497     } catch (Dali::DaliException e) {
70498       {
70499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70500       };
70501     } catch (...) {
70502       {
70503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70504       };
70505     }
70506   }
70507
70508 }
70509
70510
70511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70512   void * jresult ;
70513   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70514   int arg2 ;
70515   float arg3 ;
70516   Dali::Vector3 *arg4 = 0 ;
70517   Dali::Vector3 result;
70518
70519   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70520   arg2 = (int)jarg2;
70521   arg3 = (float)jarg3;
70522   arg4 = (Dali::Vector3 *)jarg4;
70523   if (!arg4) {
70524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70525     return 0;
70526   }
70527   {
70528     try {
70529       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70530     } catch (std::out_of_range& e) {
70531       {
70532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70533       };
70534     } catch (std::exception& e) {
70535       {
70536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70537       };
70538     } catch (Dali::DaliException e) {
70539       {
70540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70541       };
70542     } catch (...) {
70543       {
70544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70545       };
70546     }
70547   }
70548
70549   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70550   return jresult;
70551 }
70552
70553
70554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70555   void * jresult ;
70556   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70557   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70558
70559   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70560   {
70561     try {
70562       result = Dali::Toolkit::DefaultItemLayout::New(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::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70583   return jresult;
70584 }
70585
70586
70587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70588   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70589
70590   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70591   {
70592     try {
70593       delete arg1;
70594     } catch (std::out_of_range& e) {
70595       {
70596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70597       };
70598     } catch (std::exception& e) {
70599       {
70600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70601       };
70602     } catch (Dali::DaliException e) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70605       };
70606     } catch (...) {
70607       {
70608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70609       };
70610     }
70611   }
70612
70613 }
70614
70615
70616 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70617   unsigned int jresult ;
70618   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70619   unsigned int result;
70620
70621   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70622   {
70623     try {
70624       result = (unsigned int)(arg1)->GetNumberOfItems();
70625     } catch (std::out_of_range& e) {
70626       {
70627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70628       };
70629     } catch (std::exception& e) {
70630       {
70631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70632       };
70633     } catch (Dali::DaliException e) {
70634       {
70635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70636       };
70637     } catch (...) {
70638       {
70639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70640       };
70641     }
70642   }
70643
70644   jresult = result;
70645   return jresult;
70646 }
70647
70648
70649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70650   void * jresult ;
70651   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70652   unsigned int arg2 ;
70653   Dali::Actor result;
70654
70655   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70656   arg2 = (unsigned int)jarg2;
70657   {
70658     try {
70659       result = (arg1)->NewItem(arg2);
70660     } catch (std::out_of_range& e) {
70661       {
70662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70663       };
70664     } catch (std::exception& e) {
70665       {
70666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70667       };
70668     } catch (Dali::DaliException e) {
70669       {
70670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70671       };
70672     } catch (...) {
70673       {
70674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70675       };
70676     }
70677   }
70678
70679   jresult = new Dali::Actor((const Dali::Actor &)result);
70680   return jresult;
70681 }
70682
70683
70684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70685   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70686   unsigned int arg2 ;
70687   Dali::Actor arg3 ;
70688   Dali::Actor *argp3 ;
70689
70690   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70691   arg2 = (unsigned int)jarg2;
70692   argp3 = (Dali::Actor *)jarg3;
70693   if (!argp3) {
70694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70695     return ;
70696   }
70697   arg3 = *argp3;
70698   {
70699     try {
70700       (arg1)->ItemReleased(arg2,arg3);
70701     } catch (std::out_of_range& e) {
70702       {
70703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70704       };
70705     } catch (std::exception& e) {
70706       {
70707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70708       };
70709     } catch (Dali::DaliException e) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70712       };
70713     } catch (...) {
70714       {
70715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70716       };
70717     }
70718   }
70719
70720 }
70721
70722
70723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70724   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70725   unsigned int arg2 ;
70726   Dali::Actor arg3 ;
70727   Dali::Actor *argp3 ;
70728
70729   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70730   arg2 = (unsigned int)jarg2;
70731   argp3 = (Dali::Actor *)jarg3;
70732   if (!argp3) {
70733     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70734     return ;
70735   }
70736   arg3 = *argp3;
70737   {
70738     try {
70739       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70740     } catch (std::out_of_range& e) {
70741       {
70742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70743       };
70744     } catch (std::exception& e) {
70745       {
70746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70747       };
70748     } catch (Dali::DaliException e) {
70749       {
70750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70751       };
70752     } catch (...) {
70753       {
70754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70755       };
70756     }
70757   }
70758
70759 }
70760
70761
70762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70763   void * jresult ;
70764   Dali::Toolkit::ItemFactory *result = 0 ;
70765
70766   {
70767     try {
70768       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70769     } catch (std::out_of_range& e) {
70770       {
70771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70772       };
70773     } catch (std::exception& e) {
70774       {
70775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70776       };
70777     } catch (Dali::DaliException e) {
70778       {
70779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70780       };
70781     } catch (...) {
70782       {
70783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70784       };
70785     }
70786   }
70787
70788   jresult = (void *)result;
70789   return jresult;
70790 }
70791
70792
70793 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) {
70794   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70795   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70796   if (director) {
70797     director->swig_connect_director(callback0, callback1, callback2);
70798   }
70799 }
70800
70801
70802 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70803   int jresult ;
70804   int result;
70805
70806   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70807   jresult = (int)result;
70808   return jresult;
70809 }
70810
70811
70812 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70813   int jresult ;
70814   int result;
70815
70816   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70817   jresult = (int)result;
70818   return jresult;
70819 }
70820
70821
70822 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70823   int jresult ;
70824   int result;
70825
70826   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70827   jresult = (int)result;
70828   return jresult;
70829 }
70830
70831
70832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70833   int jresult ;
70834   int result;
70835
70836   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70837   jresult = (int)result;
70838   return jresult;
70839 }
70840
70841
70842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70843   int jresult ;
70844   int result;
70845
70846   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70847   jresult = (int)result;
70848   return jresult;
70849 }
70850
70851
70852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70853   int jresult ;
70854   int result;
70855
70856   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70857   jresult = (int)result;
70858   return jresult;
70859 }
70860
70861
70862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70863   int jresult ;
70864   int result;
70865
70866   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70867   jresult = (int)result;
70868   return jresult;
70869 }
70870
70871
70872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70873   int jresult ;
70874   int result;
70875
70876   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70877   jresult = (int)result;
70878   return jresult;
70879 }
70880
70881
70882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70883   int jresult ;
70884   int result;
70885
70886   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70887   jresult = (int)result;
70888   return jresult;
70889 }
70890
70891
70892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70893   int jresult ;
70894   int result;
70895
70896   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70897   jresult = (int)result;
70898   return jresult;
70899 }
70900
70901
70902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70903   int jresult ;
70904   int result;
70905
70906   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70907   jresult = (int)result;
70908   return jresult;
70909 }
70910
70911
70912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70913   void * jresult ;
70914   Dali::Toolkit::ItemView::Property *result = 0 ;
70915
70916   {
70917     try {
70918       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70919     } catch (std::out_of_range& e) {
70920       {
70921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70922       };
70923     } catch (std::exception& e) {
70924       {
70925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70926       };
70927     } catch (Dali::DaliException e) {
70928       {
70929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70930       };
70931     } catch (...) {
70932       {
70933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70934       };
70935     }
70936   }
70937
70938   jresult = (void *)result;
70939   return jresult;
70940 }
70941
70942
70943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70944   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70945
70946   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70947   {
70948     try {
70949       delete arg1;
70950     } catch (std::out_of_range& e) {
70951       {
70952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70953       };
70954     } catch (std::exception& e) {
70955       {
70956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70957       };
70958     } catch (Dali::DaliException e) {
70959       {
70960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70961       };
70962     } catch (...) {
70963       {
70964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70965       };
70966     }
70967   }
70968
70969 }
70970
70971
70972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70973   void * jresult ;
70974   Dali::Toolkit::ItemView *result = 0 ;
70975
70976   {
70977     try {
70978       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70979     } catch (std::out_of_range& e) {
70980       {
70981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70982       };
70983     } catch (std::exception& e) {
70984       {
70985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70986       };
70987     } catch (Dali::DaliException e) {
70988       {
70989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70990       };
70991     } catch (...) {
70992       {
70993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70994       };
70995     }
70996   }
70997
70998   jresult = (void *)result;
70999   return jresult;
71000 }
71001
71002
71003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
71004   void * jresult ;
71005   Dali::Toolkit::ItemView *arg1 = 0 ;
71006   Dali::Toolkit::ItemView *result = 0 ;
71007
71008   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71009   if (!arg1) {
71010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
71011     return 0;
71012   }
71013   {
71014     try {
71015       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
71016     } catch (std::out_of_range& e) {
71017       {
71018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71019       };
71020     } catch (std::exception& e) {
71021       {
71022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71023       };
71024     } catch (Dali::DaliException e) {
71025       {
71026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71027       };
71028     } catch (...) {
71029       {
71030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71031       };
71032     }
71033   }
71034
71035   jresult = (void *)result;
71036   return jresult;
71037 }
71038
71039
71040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
71041   void * jresult ;
71042   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71043   Dali::Toolkit::ItemView *arg2 = 0 ;
71044   Dali::Toolkit::ItemView *result = 0 ;
71045
71046   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71047   arg2 = (Dali::Toolkit::ItemView *)jarg2;
71048   if (!arg2) {
71049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
71050     return 0;
71051   }
71052   {
71053     try {
71054       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
71055     } catch (std::out_of_range& e) {
71056       {
71057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71058       };
71059     } catch (std::exception& e) {
71060       {
71061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71062       };
71063     } catch (Dali::DaliException e) {
71064       {
71065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71066       };
71067     } catch (...) {
71068       {
71069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71070       };
71071     }
71072   }
71073
71074   jresult = (void *)result;
71075   return jresult;
71076 }
71077
71078
71079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
71080   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71081
71082   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71083   {
71084     try {
71085       delete arg1;
71086     } catch (std::out_of_range& e) {
71087       {
71088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71089       };
71090     } catch (std::exception& e) {
71091       {
71092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71093       };
71094     } catch (Dali::DaliException e) {
71095       {
71096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71097       };
71098     } catch (...) {
71099       {
71100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71101       };
71102     }
71103   }
71104
71105 }
71106
71107
71108 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
71109   void * jresult ;
71110   Dali::Toolkit::ItemFactory *arg1 = 0 ;
71111   Dali::Toolkit::ItemView result;
71112
71113   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
71114   if (!arg1) {
71115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
71116     return 0;
71117   }
71118   {
71119     try {
71120       result = Dali::Toolkit::ItemView::New(*arg1);
71121     } catch (std::out_of_range& e) {
71122       {
71123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71124       };
71125     } catch (std::exception& e) {
71126       {
71127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71128       };
71129     } catch (Dali::DaliException e) {
71130       {
71131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71132       };
71133     } catch (...) {
71134       {
71135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71136       };
71137     }
71138   }
71139
71140   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71141   return jresult;
71142 }
71143
71144
71145 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
71146   void * jresult ;
71147   Dali::BaseHandle arg1 ;
71148   Dali::BaseHandle *argp1 ;
71149   Dali::Toolkit::ItemView result;
71150
71151   argp1 = (Dali::BaseHandle *)jarg1;
71152   if (!argp1) {
71153     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
71154     return 0;
71155   }
71156   arg1 = *argp1;
71157   {
71158     try {
71159       result = Dali::Toolkit::ItemView::DownCast(arg1);
71160     } catch (std::out_of_range& e) {
71161       {
71162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71163       };
71164     } catch (std::exception& e) {
71165       {
71166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71167       };
71168     } catch (Dali::DaliException e) {
71169       {
71170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71171       };
71172     } catch (...) {
71173       {
71174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71175       };
71176     }
71177   }
71178
71179   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
71180   return jresult;
71181 }
71182
71183
71184 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
71185   unsigned int jresult ;
71186   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71187   unsigned int result;
71188
71189   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71190   {
71191     try {
71192       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
71193     } catch (std::out_of_range& e) {
71194       {
71195         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71196       };
71197     } catch (std::exception& e) {
71198       {
71199         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71200       };
71201     } catch (Dali::DaliException e) {
71202       {
71203         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71204       };
71205     } catch (...) {
71206       {
71207         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71208       };
71209     }
71210   }
71211
71212   jresult = result;
71213   return jresult;
71214 }
71215
71216
71217 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
71218   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71219   Dali::Toolkit::ItemLayout *arg2 = 0 ;
71220
71221   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71222   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
71223   if (!arg2) {
71224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
71225     return ;
71226   }
71227   {
71228     try {
71229       (arg1)->AddLayout(*arg2);
71230     } catch (std::out_of_range& e) {
71231       {
71232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71233       };
71234     } catch (std::exception& e) {
71235       {
71236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71237       };
71238     } catch (Dali::DaliException e) {
71239       {
71240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71241       };
71242     } catch (...) {
71243       {
71244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71245       };
71246     }
71247   }
71248
71249 }
71250
71251
71252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
71253   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71254   unsigned int arg2 ;
71255
71256   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71257   arg2 = (unsigned int)jarg2;
71258   {
71259     try {
71260       (arg1)->RemoveLayout(arg2);
71261     } catch (std::out_of_range& e) {
71262       {
71263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71264       };
71265     } catch (std::exception& e) {
71266       {
71267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71268       };
71269     } catch (Dali::DaliException e) {
71270       {
71271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71272       };
71273     } catch (...) {
71274       {
71275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71276       };
71277     }
71278   }
71279
71280 }
71281
71282
71283 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
71284   void * jresult ;
71285   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71286   unsigned int arg2 ;
71287   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71288
71289   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71290   arg2 = (unsigned int)jarg2;
71291   {
71292     try {
71293       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
71294     } catch (std::out_of_range& e) {
71295       {
71296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71297       };
71298     } catch (std::exception& e) {
71299       {
71300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71301       };
71302     } catch (Dali::DaliException e) {
71303       {
71304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71305       };
71306     } catch (...) {
71307       {
71308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71309       };
71310     }
71311   }
71312
71313   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71314   return jresult;
71315 }
71316
71317
71318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
71319   void * jresult ;
71320   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71321   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
71322
71323   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71324   {
71325     try {
71326       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
71327     } catch (std::out_of_range& e) {
71328       {
71329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71330       };
71331     } catch (std::exception& e) {
71332       {
71333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71334       };
71335     } catch (Dali::DaliException e) {
71336       {
71337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71338       };
71339     } catch (...) {
71340       {
71341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71342       };
71343     }
71344   }
71345
71346   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
71347   return jresult;
71348 }
71349
71350
71351 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
71352   float jresult ;
71353   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71354   Dali::Toolkit::ItemId arg2 ;
71355   float result;
71356
71357   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71358   arg2 = (Dali::Toolkit::ItemId)jarg2;
71359   {
71360     try {
71361       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
71362     } catch (std::out_of_range& e) {
71363       {
71364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71365       };
71366     } catch (std::exception& e) {
71367       {
71368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71369       };
71370     } catch (Dali::DaliException e) {
71371       {
71372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71373       };
71374     } catch (...) {
71375       {
71376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71377       };
71378     }
71379   }
71380
71381   jresult = result;
71382   return jresult;
71383 }
71384
71385
71386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
71387   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71388   unsigned int arg2 ;
71389   Dali::Vector3 arg3 ;
71390   float arg4 ;
71391   Dali::Vector3 *argp3 ;
71392
71393   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71394   arg2 = (unsigned int)jarg2;
71395   argp3 = (Dali::Vector3 *)jarg3;
71396   if (!argp3) {
71397     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
71398     return ;
71399   }
71400   arg3 = *argp3;
71401   arg4 = (float)jarg4;
71402   {
71403     try {
71404       (arg1)->ActivateLayout(arg2,arg3,arg4);
71405     } catch (std::out_of_range& e) {
71406       {
71407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71408       };
71409     } catch (std::exception& e) {
71410       {
71411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71412       };
71413     } catch (Dali::DaliException e) {
71414       {
71415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71416       };
71417     } catch (...) {
71418       {
71419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71420       };
71421     }
71422   }
71423
71424 }
71425
71426
71427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
71428   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71429
71430   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71431   {
71432     try {
71433       (arg1)->DeactivateCurrentLayout();
71434     } catch (std::out_of_range& e) {
71435       {
71436         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71437       };
71438     } catch (std::exception& e) {
71439       {
71440         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71441       };
71442     } catch (Dali::DaliException e) {
71443       {
71444         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71445       };
71446     } catch (...) {
71447       {
71448         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71449       };
71450     }
71451   }
71452
71453 }
71454
71455
71456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
71457   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71458   float arg2 ;
71459
71460   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71461   arg2 = (float)jarg2;
71462   {
71463     try {
71464       (arg1)->SetMinimumSwipeSpeed(arg2);
71465     } catch (std::out_of_range& e) {
71466       {
71467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71468       };
71469     } catch (std::exception& e) {
71470       {
71471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71472       };
71473     } catch (Dali::DaliException e) {
71474       {
71475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71476       };
71477     } catch (...) {
71478       {
71479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71480       };
71481     }
71482   }
71483
71484 }
71485
71486
71487 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
71488   float jresult ;
71489   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71490   float result;
71491
71492   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71493   {
71494     try {
71495       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71496     } catch (std::out_of_range& e) {
71497       {
71498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71499       };
71500     } catch (std::exception& e) {
71501       {
71502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71503       };
71504     } catch (Dali::DaliException e) {
71505       {
71506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71507       };
71508     } catch (...) {
71509       {
71510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71511       };
71512     }
71513   }
71514
71515   jresult = result;
71516   return jresult;
71517 }
71518
71519
71520 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71521   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71522   float arg2 ;
71523
71524   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71525   arg2 = (float)jarg2;
71526   {
71527     try {
71528       (arg1)->SetMinimumSwipeDistance(arg2);
71529     } catch (std::out_of_range& e) {
71530       {
71531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71532       };
71533     } catch (std::exception& e) {
71534       {
71535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71536       };
71537     } catch (Dali::DaliException e) {
71538       {
71539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71540       };
71541     } catch (...) {
71542       {
71543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71544       };
71545     }
71546   }
71547
71548 }
71549
71550
71551 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71552   float jresult ;
71553   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71554   float result;
71555
71556   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71557   {
71558     try {
71559       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71560     } catch (std::out_of_range& e) {
71561       {
71562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71563       };
71564     } catch (std::exception& e) {
71565       {
71566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71567       };
71568     } catch (Dali::DaliException e) {
71569       {
71570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71571       };
71572     } catch (...) {
71573       {
71574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71575       };
71576     }
71577   }
71578
71579   jresult = result;
71580   return jresult;
71581 }
71582
71583
71584 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71585   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71586   float arg2 ;
71587
71588   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71589   arg2 = (float)jarg2;
71590   {
71591     try {
71592       (arg1)->SetWheelScrollDistanceStep(arg2);
71593     } catch (std::out_of_range& e) {
71594       {
71595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71596       };
71597     } catch (std::exception& e) {
71598       {
71599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71600       };
71601     } catch (Dali::DaliException e) {
71602       {
71603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71604       };
71605     } catch (...) {
71606       {
71607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71608       };
71609     }
71610   }
71611
71612 }
71613
71614
71615 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71616   float jresult ;
71617   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71618   float result;
71619
71620   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71621   {
71622     try {
71623       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71624     } catch (std::out_of_range& e) {
71625       {
71626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71627       };
71628     } catch (std::exception& e) {
71629       {
71630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71631       };
71632     } catch (Dali::DaliException e) {
71633       {
71634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71635       };
71636     } catch (...) {
71637       {
71638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71639       };
71640     }
71641   }
71642
71643   jresult = result;
71644   return jresult;
71645 }
71646
71647
71648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71649   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71650   bool arg2 ;
71651
71652   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71653   arg2 = jarg2 ? true : false;
71654   {
71655     try {
71656       (arg1)->SetAnchoring(arg2);
71657     } catch (std::out_of_range& e) {
71658       {
71659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71660       };
71661     } catch (std::exception& e) {
71662       {
71663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71664       };
71665     } catch (Dali::DaliException e) {
71666       {
71667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71668       };
71669     } catch (...) {
71670       {
71671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71672       };
71673     }
71674   }
71675
71676 }
71677
71678 //// ========================= end of part 3 =============================
71679
71680 //// ========================== start part 4 ===============================
71681
71682
71683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71684   unsigned int jresult ;
71685   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71686   bool result;
71687
71688   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71689   {
71690     try {
71691       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71692     } catch (std::out_of_range& e) {
71693       {
71694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71695       };
71696     } catch (std::exception& e) {
71697       {
71698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71699       };
71700     } catch (Dali::DaliException e) {
71701       {
71702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71703       };
71704     } catch (...) {
71705       {
71706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71707       };
71708     }
71709   }
71710
71711   jresult = result;
71712   return jresult;
71713 }
71714
71715
71716 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71717   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71718   float arg2 ;
71719
71720   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71721   arg2 = (float)jarg2;
71722   {
71723     try {
71724       (arg1)->SetAnchoringDuration(arg2);
71725     } catch (std::out_of_range& e) {
71726       {
71727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71728       };
71729     } catch (std::exception& e) {
71730       {
71731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71732       };
71733     } catch (Dali::DaliException e) {
71734       {
71735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71736       };
71737     } catch (...) {
71738       {
71739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71740       };
71741     }
71742   }
71743
71744 }
71745
71746
71747 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71748   float jresult ;
71749   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71750   float result;
71751
71752   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71753   {
71754     try {
71755       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71756     } catch (std::out_of_range& e) {
71757       {
71758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71759       };
71760     } catch (std::exception& e) {
71761       {
71762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71763       };
71764     } catch (Dali::DaliException e) {
71765       {
71766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71767       };
71768     } catch (...) {
71769       {
71770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71771       };
71772     }
71773   }
71774
71775   jresult = result;
71776   return jresult;
71777 }
71778
71779
71780 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71781   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71782   Dali::Toolkit::ItemId arg2 ;
71783   float arg3 ;
71784
71785   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71786   arg2 = (Dali::Toolkit::ItemId)jarg2;
71787   arg3 = (float)jarg3;
71788   {
71789     try {
71790       (arg1)->ScrollToItem(arg2,arg3);
71791     } catch (std::out_of_range& e) {
71792       {
71793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71794       };
71795     } catch (std::exception& e) {
71796       {
71797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71798       };
71799     } catch (Dali::DaliException e) {
71800       {
71801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71802       };
71803     } catch (...) {
71804       {
71805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71806       };
71807     }
71808   }
71809
71810 }
71811
71812
71813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71814   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71815   float arg2 ;
71816
71817   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71818   arg2 = (float)jarg2;
71819   {
71820     try {
71821       (arg1)->SetRefreshInterval(arg2);
71822     } catch (std::out_of_range& e) {
71823       {
71824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71825       };
71826     } catch (std::exception& e) {
71827       {
71828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71829       };
71830     } catch (Dali::DaliException e) {
71831       {
71832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71833       };
71834     } catch (...) {
71835       {
71836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71837       };
71838     }
71839   }
71840
71841 }
71842
71843
71844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71845   float jresult ;
71846   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71847   float result;
71848
71849   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71850   {
71851     try {
71852       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
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 = result;
71873   return jresult;
71874 }
71875
71876
71877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71878   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71879
71880   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71881   {
71882     try {
71883       (arg1)->Refresh();
71884     } catch (std::out_of_range& e) {
71885       {
71886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71887       };
71888     } catch (std::exception& e) {
71889       {
71890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71891       };
71892     } catch (Dali::DaliException e) {
71893       {
71894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71895       };
71896     } catch (...) {
71897       {
71898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71899       };
71900     }
71901   }
71902
71903 }
71904
71905
71906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71907   void * jresult ;
71908   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71909   Dali::Toolkit::ItemId arg2 ;
71910   Dali::Actor result;
71911
71912   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71913   arg2 = (Dali::Toolkit::ItemId)jarg2;
71914   {
71915     try {
71916       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71917     } catch (std::out_of_range& e) {
71918       {
71919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71920       };
71921     } catch (std::exception& e) {
71922       {
71923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71924       };
71925     } catch (Dali::DaliException e) {
71926       {
71927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71928       };
71929     } catch (...) {
71930       {
71931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71932       };
71933     }
71934   }
71935
71936   jresult = new Dali::Actor((const Dali::Actor &)result);
71937   return jresult;
71938 }
71939
71940
71941 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71942   unsigned int jresult ;
71943   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71944   Dali::Actor arg2 ;
71945   Dali::Actor *argp2 ;
71946   Dali::Toolkit::ItemId result;
71947
71948   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71949   argp2 = (Dali::Actor *)jarg2;
71950   if (!argp2) {
71951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71952     return 0;
71953   }
71954   arg2 = *argp2;
71955   {
71956     try {
71957       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71958     } catch (std::out_of_range& e) {
71959       {
71960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71961       };
71962     } catch (std::exception& e) {
71963       {
71964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71965       };
71966     } catch (Dali::DaliException e) {
71967       {
71968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71969       };
71970     } catch (...) {
71971       {
71972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71973       };
71974     }
71975   }
71976
71977   jresult = result;
71978   return jresult;
71979 }
71980
71981
71982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71983   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71984   Dali::Toolkit::Item arg2 ;
71985   float arg3 ;
71986   Dali::Toolkit::Item *argp2 ;
71987
71988   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71989   argp2 = (Dali::Toolkit::Item *)jarg2;
71990   if (!argp2) {
71991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71992     return ;
71993   }
71994   arg2 = *argp2;
71995   arg3 = (float)jarg3;
71996   {
71997     try {
71998       (arg1)->InsertItem(arg2,arg3);
71999     } catch (std::out_of_range& e) {
72000       {
72001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72002       };
72003     } catch (std::exception& e) {
72004       {
72005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72006       };
72007     } catch (Dali::DaliException e) {
72008       {
72009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72010       };
72011     } catch (...) {
72012       {
72013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72014       };
72015     }
72016   }
72017
72018 }
72019
72020
72021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
72022   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72023   Dali::Toolkit::ItemContainer *arg2 = 0 ;
72024   float arg3 ;
72025
72026   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72027   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
72028   if (!arg2) {
72029     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
72030     return ;
72031   }
72032   arg3 = (float)jarg3;
72033   {
72034     try {
72035       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
72036     } catch (std::out_of_range& e) {
72037       {
72038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72039       };
72040     } catch (std::exception& e) {
72041       {
72042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72043       };
72044     } catch (Dali::DaliException e) {
72045       {
72046         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72047       };
72048     } catch (...) {
72049       {
72050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72051       };
72052     }
72053   }
72054
72055 }
72056
72057
72058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
72059   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72060   Dali::Toolkit::ItemId arg2 ;
72061   float arg3 ;
72062
72063   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72064   arg2 = (Dali::Toolkit::ItemId)jarg2;
72065   arg3 = (float)jarg3;
72066   {
72067     try {
72068       (arg1)->RemoveItem(arg2,arg3);
72069     } catch (std::out_of_range& e) {
72070       {
72071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72072       };
72073     } catch (std::exception& e) {
72074       {
72075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72076       };
72077     } catch (Dali::DaliException e) {
72078       {
72079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72080       };
72081     } catch (...) {
72082       {
72083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72084       };
72085     }
72086   }
72087
72088 }
72089
72090
72091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
72092   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72093   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
72094   float arg3 ;
72095
72096   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72097   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
72098   if (!arg2) {
72099     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
72100     return ;
72101   }
72102   arg3 = (float)jarg3;
72103   {
72104     try {
72105       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
72106     } catch (std::out_of_range& e) {
72107       {
72108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72109       };
72110     } catch (std::exception& e) {
72111       {
72112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72113       };
72114     } catch (Dali::DaliException e) {
72115       {
72116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72117       };
72118     } catch (...) {
72119       {
72120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72121       };
72122     }
72123   }
72124
72125 }
72126
72127
72128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
72129   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72130   Dali::Toolkit::Item arg2 ;
72131   float arg3 ;
72132   Dali::Toolkit::Item *argp2 ;
72133
72134   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72135   argp2 = (Dali::Toolkit::Item *)jarg2;
72136   if (!argp2) {
72137     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
72138     return ;
72139   }
72140   arg2 = *argp2;
72141   arg3 = (float)jarg3;
72142   {
72143     try {
72144       (arg1)->ReplaceItem(arg2,arg3);
72145     } catch (std::out_of_range& e) {
72146       {
72147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72148       };
72149     } catch (std::exception& e) {
72150       {
72151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72152       };
72153     } catch (Dali::DaliException e) {
72154       {
72155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72156       };
72157     } catch (...) {
72158       {
72159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72160       };
72161     }
72162   }
72163
72164 }
72165
72166
72167 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
72168   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72169   Dali::Toolkit::ItemContainer *arg2 = 0 ;
72170   float arg3 ;
72171
72172   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72173   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
72174   if (!arg2) {
72175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
72176     return ;
72177   }
72178   arg3 = (float)jarg3;
72179   {
72180     try {
72181       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
72182     } catch (std::out_of_range& e) {
72183       {
72184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72185       };
72186     } catch (std::exception& e) {
72187       {
72188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72189       };
72190     } catch (Dali::DaliException e) {
72191       {
72192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72193       };
72194     } catch (...) {
72195       {
72196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72197       };
72198     }
72199   }
72200
72201 }
72202
72203
72204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
72205   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72206   Dali::Vector3 *arg2 = 0 ;
72207
72208   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72209   arg2 = (Dali::Vector3 *)jarg2;
72210   if (!arg2) {
72211     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72212     return ;
72213   }
72214   {
72215     try {
72216       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
72217     } catch (std::out_of_range& e) {
72218       {
72219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72220       };
72221     } catch (std::exception& e) {
72222       {
72223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72224       };
72225     } catch (Dali::DaliException e) {
72226       {
72227         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72228       };
72229     } catch (...) {
72230       {
72231         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72232       };
72233     }
72234   }
72235
72236 }
72237
72238
72239 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
72240   void * jresult ;
72241   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72242   Dali::Vector3 result;
72243
72244   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72245   {
72246     try {
72247       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
72248     } catch (std::out_of_range& e) {
72249       {
72250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72251       };
72252     } catch (std::exception& e) {
72253       {
72254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72255       };
72256     } catch (Dali::DaliException e) {
72257       {
72258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72259       };
72260     } catch (...) {
72261       {
72262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72263       };
72264     }
72265   }
72266
72267   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72268   return jresult;
72269 }
72270
72271
72272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
72273   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72274   Dali::Vector3 *arg2 = 0 ;
72275
72276   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72277   arg2 = (Dali::Vector3 *)jarg2;
72278   if (!arg2) {
72279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72280     return ;
72281   }
72282   {
72283     try {
72284       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
72285     } catch (std::out_of_range& e) {
72286       {
72287         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72288       };
72289     } catch (std::exception& e) {
72290       {
72291         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72292       };
72293     } catch (Dali::DaliException e) {
72294       {
72295         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72296       };
72297     } catch (...) {
72298       {
72299         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72300       };
72301     }
72302   }
72303
72304 }
72305
72306
72307 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
72308   void * jresult ;
72309   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72310   Dali::Vector3 result;
72311
72312   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72313   {
72314     try {
72315       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
72316     } catch (std::out_of_range& e) {
72317       {
72318         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72319       };
72320     } catch (std::exception& e) {
72321       {
72322         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72323       };
72324     } catch (Dali::DaliException e) {
72325       {
72326         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72327       };
72328     } catch (...) {
72329       {
72330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72331       };
72332     }
72333   }
72334
72335   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
72336   return jresult;
72337 }
72338
72339
72340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
72341   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72342   Dali::Toolkit::ItemRange *arg2 = 0 ;
72343
72344   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72345   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
72346   if (!arg2) {
72347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
72348     return ;
72349   }
72350   {
72351     try {
72352       (arg1)->GetItemsRange(*arg2);
72353     } catch (std::out_of_range& e) {
72354       {
72355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72356       };
72357     } catch (std::exception& e) {
72358       {
72359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72360       };
72361     } catch (Dali::DaliException e) {
72362       {
72363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72364       };
72365     } catch (...) {
72366       {
72367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72368       };
72369     }
72370   }
72371
72372 }
72373
72374
72375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
72376   void * jresult ;
72377   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
72378   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
72379
72380   arg1 = (Dali::Toolkit::ItemView *)jarg1;
72381   {
72382     try {
72383       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
72384     } catch (std::out_of_range& e) {
72385       {
72386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72387       };
72388     } catch (std::exception& e) {
72389       {
72390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72391       };
72392     } catch (Dali::DaliException e) {
72393       {
72394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72395       };
72396     } catch (...) {
72397       {
72398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72399       };
72400     }
72401   }
72402
72403   jresult = (void *)result;
72404   return jresult;
72405 }
72406
72407
72408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
72409   Dali::Vector3 *arg1 = 0 ;
72410   PropertyInputContainer *arg2 = 0 ;
72411
72412   arg1 = (Dali::Vector3 *)jarg1;
72413   if (!arg1) {
72414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72415     return ;
72416   }
72417   arg2 = (PropertyInputContainer *)jarg2;
72418   if (!arg2) {
72419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72420     return ;
72421   }
72422   {
72423     try {
72424       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72425     } catch (std::out_of_range& e) {
72426       {
72427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72428       };
72429     } catch (std::exception& e) {
72430       {
72431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72432       };
72433     } catch (Dali::DaliException e) {
72434       {
72435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72436       };
72437     } catch (...) {
72438       {
72439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72440       };
72441     }
72442   }
72443
72444 }
72445
72446
72447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
72448   Dali::Vector3 *arg1 = 0 ;
72449   PropertyInputContainer *arg2 = 0 ;
72450
72451   arg1 = (Dali::Vector3 *)jarg1;
72452   if (!arg1) {
72453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
72454     return ;
72455   }
72456   arg2 = (PropertyInputContainer *)jarg2;
72457   if (!arg2) {
72458     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
72459     return ;
72460   }
72461   {
72462     try {
72463       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
72464     } catch (std::out_of_range& e) {
72465       {
72466         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72467       };
72468     } catch (std::exception& e) {
72469       {
72470         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72471       };
72472     } catch (Dali::DaliException e) {
72473       {
72474         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72475       };
72476     } catch (...) {
72477       {
72478         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72479       };
72480     }
72481   }
72482
72483 }
72484
72485
72486 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
72487   void * jresult ;
72488   Dali::Toolkit::ScrollViewEffect *result = 0 ;
72489
72490   {
72491     try {
72492       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
72493     } catch (std::out_of_range& e) {
72494       {
72495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72496       };
72497     } catch (std::exception& e) {
72498       {
72499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72500       };
72501     } catch (Dali::DaliException e) {
72502       {
72503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72504       };
72505     } catch (...) {
72506       {
72507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72508       };
72509     }
72510   }
72511
72512   jresult = (void *)result;
72513   return jresult;
72514 }
72515
72516
72517 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72518   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72519
72520   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72521   {
72522     try {
72523       delete arg1;
72524     } catch (std::out_of_range& e) {
72525       {
72526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72527       };
72528     } catch (std::exception& e) {
72529       {
72530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72531       };
72532     } catch (Dali::DaliException e) {
72533       {
72534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72535       };
72536     } catch (...) {
72537       {
72538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72539       };
72540     }
72541   }
72542
72543 }
72544
72545
72546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72547   void * jresult ;
72548   Dali::Path arg1 ;
72549   Dali::Vector3 *arg2 = 0 ;
72550   Dali::Property::Index arg3 ;
72551   Dali::Vector3 *arg4 = 0 ;
72552   unsigned int arg5 ;
72553   Dali::Path *argp1 ;
72554   Dali::Toolkit::ScrollViewPagePathEffect result;
72555
72556   argp1 = (Dali::Path *)jarg1;
72557   if (!argp1) {
72558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72559     return 0;
72560   }
72561   arg1 = *argp1;
72562   arg2 = (Dali::Vector3 *)jarg2;
72563   if (!arg2) {
72564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72565     return 0;
72566   }
72567   arg3 = (Dali::Property::Index)jarg3;
72568   arg4 = (Dali::Vector3 *)jarg4;
72569   if (!arg4) {
72570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72571     return 0;
72572   }
72573   arg5 = (unsigned int)jarg5;
72574   {
72575     try {
72576       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72577     } catch (std::out_of_range& e) {
72578       {
72579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72580       };
72581     } catch (std::exception& e) {
72582       {
72583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72584       };
72585     } catch (Dali::DaliException e) {
72586       {
72587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72588       };
72589     } catch (...) {
72590       {
72591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72592       };
72593     }
72594   }
72595
72596   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72597   return jresult;
72598 }
72599
72600
72601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72602   void * jresult ;
72603   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72604
72605   {
72606     try {
72607       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72608     } catch (std::out_of_range& e) {
72609       {
72610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72611       };
72612     } catch (std::exception& e) {
72613       {
72614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72615       };
72616     } catch (Dali::DaliException e) {
72617       {
72618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72619       };
72620     } catch (...) {
72621       {
72622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72623       };
72624     }
72625   }
72626
72627   jresult = (void *)result;
72628   return jresult;
72629 }
72630
72631
72632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72633   void * jresult ;
72634   Dali::BaseHandle arg1 ;
72635   Dali::BaseHandle *argp1 ;
72636   Dali::Toolkit::ScrollViewPagePathEffect result;
72637
72638   argp1 = (Dali::BaseHandle *)jarg1;
72639   if (!argp1) {
72640     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72641     return 0;
72642   }
72643   arg1 = *argp1;
72644   {
72645     try {
72646       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72647     } catch (std::out_of_range& e) {
72648       {
72649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72650       };
72651     } catch (std::exception& e) {
72652       {
72653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72654       };
72655     } catch (Dali::DaliException e) {
72656       {
72657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72658       };
72659     } catch (...) {
72660       {
72661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72662       };
72663     }
72664   }
72665
72666   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72667   return jresult;
72668 }
72669
72670
72671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72672   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72673   Dali::Actor arg2 ;
72674   unsigned int arg3 ;
72675   Dali::Actor *argp2 ;
72676
72677   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72678   argp2 = (Dali::Actor *)jarg2;
72679   if (!argp2) {
72680     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72681     return ;
72682   }
72683   arg2 = *argp2;
72684   arg3 = (unsigned int)jarg3;
72685   {
72686     try {
72687       (arg1)->ApplyToPage(arg2,arg3);
72688     } catch (std::out_of_range& e) {
72689       {
72690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72691       };
72692     } catch (std::exception& e) {
72693       {
72694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72695       };
72696     } catch (Dali::DaliException e) {
72697       {
72698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72699       };
72700     } catch (...) {
72701       {
72702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72703       };
72704     }
72705   }
72706
72707 }
72708
72709
72710 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72711   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72712
72713   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72714   {
72715     try {
72716       delete arg1;
72717     } catch (std::out_of_range& e) {
72718       {
72719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72720       };
72721     } catch (std::exception& e) {
72722       {
72723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72724       };
72725     } catch (Dali::DaliException e) {
72726       {
72727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72728       };
72729     } catch (...) {
72730       {
72731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72732       };
72733     }
72734   }
72735
72736 }
72737
72738
72739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72740   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72741   Dali::Toolkit::ClampState arg2 ;
72742
72743   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72744   arg2 = (Dali::Toolkit::ClampState)jarg2;
72745   if (arg1) (arg1)->x = arg2;
72746 }
72747
72748
72749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72750   int jresult ;
72751   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72752   Dali::Toolkit::ClampState result;
72753
72754   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72755   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72756   jresult = (int)result;
72757   return jresult;
72758 }
72759
72760
72761 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72762   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72763   Dali::Toolkit::ClampState arg2 ;
72764
72765   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72766   arg2 = (Dali::Toolkit::ClampState)jarg2;
72767   if (arg1) (arg1)->y = arg2;
72768 }
72769
72770
72771 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72772   int jresult ;
72773   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72774   Dali::Toolkit::ClampState result;
72775
72776   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72777   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72778   jresult = (int)result;
72779   return jresult;
72780 }
72781
72782
72783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72784   void * jresult ;
72785   Dali::Toolkit::ClampState2D *result = 0 ;
72786
72787   {
72788     try {
72789       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72790     } catch (std::out_of_range& e) {
72791       {
72792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72793       };
72794     } catch (std::exception& e) {
72795       {
72796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72797       };
72798     } catch (Dali::DaliException e) {
72799       {
72800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72801       };
72802     } catch (...) {
72803       {
72804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72805       };
72806     }
72807   }
72808
72809   jresult = (void *)result;
72810   return jresult;
72811 }
72812
72813
72814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72815   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72816
72817   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72818   {
72819     try {
72820       delete arg1;
72821     } catch (std::out_of_range& e) {
72822       {
72823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72824       };
72825     } catch (std::exception& e) {
72826       {
72827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72828       };
72829     } catch (Dali::DaliException e) {
72830       {
72831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72832       };
72833     } catch (...) {
72834       {
72835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72836       };
72837     }
72838   }
72839
72840 }
72841
72842
72843 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72844   void * jresult ;
72845   float arg1 ;
72846   float arg2 ;
72847   bool arg3 ;
72848   Dali::Toolkit::RulerDomain *result = 0 ;
72849
72850   arg1 = (float)jarg1;
72851   arg2 = (float)jarg2;
72852   arg3 = jarg3 ? true : false;
72853   {
72854     try {
72855       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72856     } catch (std::out_of_range& e) {
72857       {
72858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72859       };
72860     } catch (std::exception& e) {
72861       {
72862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72863       };
72864     } catch (Dali::DaliException e) {
72865       {
72866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72867       };
72868     } catch (...) {
72869       {
72870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72871       };
72872     }
72873   }
72874
72875   jresult = (void *)result;
72876   return jresult;
72877 }
72878
72879
72880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72881   void * jresult ;
72882   float arg1 ;
72883   float arg2 ;
72884   Dali::Toolkit::RulerDomain *result = 0 ;
72885
72886   arg1 = (float)jarg1;
72887   arg2 = (float)jarg2;
72888   {
72889     try {
72890       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72891     } catch (std::out_of_range& e) {
72892       {
72893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72894       };
72895     } catch (std::exception& e) {
72896       {
72897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72898       };
72899     } catch (Dali::DaliException e) {
72900       {
72901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72902       };
72903     } catch (...) {
72904       {
72905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72906       };
72907     }
72908   }
72909
72910   jresult = (void *)result;
72911   return jresult;
72912 }
72913
72914
72915 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72916   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72917   float arg2 ;
72918
72919   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72920   arg2 = (float)jarg2;
72921   if (arg1) (arg1)->min = arg2;
72922 }
72923
72924
72925 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72926   float jresult ;
72927   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72928   float result;
72929
72930   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72931   result = (float) ((arg1)->min);
72932   jresult = result;
72933   return jresult;
72934 }
72935
72936
72937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72938   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72939   float arg2 ;
72940
72941   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72942   arg2 = (float)jarg2;
72943   if (arg1) (arg1)->max = arg2;
72944 }
72945
72946
72947 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72948   float jresult ;
72949   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72950   float result;
72951
72952   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72953   result = (float) ((arg1)->max);
72954   jresult = result;
72955   return jresult;
72956 }
72957
72958
72959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72960   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72961   bool arg2 ;
72962
72963   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72964   arg2 = jarg2 ? true : false;
72965   if (arg1) (arg1)->enabled = arg2;
72966 }
72967
72968
72969 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72970   unsigned int jresult ;
72971   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72972   bool result;
72973
72974   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72975   result = (bool) ((arg1)->enabled);
72976   jresult = result;
72977   return jresult;
72978 }
72979
72980
72981 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72982   float jresult ;
72983   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72984   float arg2 ;
72985   float arg3 ;
72986   float arg4 ;
72987   float result;
72988
72989   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72990   arg2 = (float)jarg2;
72991   arg3 = (float)jarg3;
72992   arg4 = (float)jarg4;
72993   {
72994     try {
72995       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72996     } catch (std::out_of_range& e) {
72997       {
72998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72999       };
73000     } catch (std::exception& e) {
73001       {
73002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73003       };
73004     } catch (Dali::DaliException e) {
73005       {
73006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73007       };
73008     } catch (...) {
73009       {
73010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73011       };
73012     }
73013   }
73014
73015   jresult = result;
73016   return jresult;
73017 }
73018
73019
73020 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73021   float jresult ;
73022   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73023   float arg2 ;
73024   float arg3 ;
73025   float result;
73026
73027   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73028   arg2 = (float)jarg2;
73029   arg3 = (float)jarg3;
73030   {
73031     try {
73032       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
73033     } catch (std::out_of_range& e) {
73034       {
73035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73036       };
73037     } catch (std::exception& e) {
73038       {
73039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73040       };
73041     } catch (Dali::DaliException e) {
73042       {
73043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73044       };
73045     } catch (...) {
73046       {
73047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73048       };
73049     }
73050   }
73051
73052   jresult = result;
73053   return jresult;
73054 }
73055
73056
73057 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
73058   float jresult ;
73059   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73060   float arg2 ;
73061   float result;
73062
73063   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73064   arg2 = (float)jarg2;
73065   {
73066     try {
73067       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
73068     } catch (std::out_of_range& e) {
73069       {
73070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73071       };
73072     } catch (std::exception& e) {
73073       {
73074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73075       };
73076     } catch (Dali::DaliException e) {
73077       {
73078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73079       };
73080     } catch (...) {
73081       {
73082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73083       };
73084     }
73085   }
73086
73087   jresult = result;
73088   return jresult;
73089 }
73090
73091
73092 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73093   float jresult ;
73094   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73095   float arg2 ;
73096   float arg3 ;
73097   float arg4 ;
73098   Dali::Toolkit::ClampState *arg5 = 0 ;
73099   float result;
73100
73101   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73102   arg2 = (float)jarg2;
73103   arg3 = (float)jarg3;
73104   arg4 = (float)jarg4;
73105   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73106   if (!arg5) {
73107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73108     return 0;
73109   }
73110   {
73111     try {
73112       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73113     } catch (std::out_of_range& e) {
73114       {
73115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73116       };
73117     } catch (std::exception& e) {
73118       {
73119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73120       };
73121     } catch (Dali::DaliException e) {
73122       {
73123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73124       };
73125     } catch (...) {
73126       {
73127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73128       };
73129     }
73130   }
73131
73132   jresult = result;
73133   return jresult;
73134 }
73135
73136
73137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
73138   float jresult ;
73139   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73140   float result;
73141
73142   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73143   {
73144     try {
73145       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
73146     } catch (std::out_of_range& e) {
73147       {
73148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73149       };
73150     } catch (std::exception& e) {
73151       {
73152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73153       };
73154     } catch (Dali::DaliException e) {
73155       {
73156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73157       };
73158     } catch (...) {
73159       {
73160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73161       };
73162     }
73163   }
73164
73165   jresult = result;
73166   return jresult;
73167 }
73168
73169
73170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
73171   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
73172
73173   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
73174   {
73175     try {
73176       delete arg1;
73177     } catch (std::out_of_range& e) {
73178       {
73179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73180       };
73181     } catch (std::exception& e) {
73182       {
73183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73184       };
73185     } catch (Dali::DaliException e) {
73186       {
73187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73188       };
73189     } catch (...) {
73190       {
73191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73192       };
73193     }
73194   }
73195
73196 }
73197
73198
73199 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
73200   float jresult ;
73201   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73202   float arg2 ;
73203   float arg3 ;
73204   float result;
73205
73206   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73207   arg2 = (float)jarg2;
73208   arg3 = (float)jarg3;
73209   {
73210     try {
73211       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
73212     } catch (std::out_of_range& e) {
73213       {
73214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73215       };
73216     } catch (std::exception& e) {
73217       {
73218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73219       };
73220     } catch (Dali::DaliException e) {
73221       {
73222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73223       };
73224     } catch (...) {
73225       {
73226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73227       };
73228     }
73229   }
73230
73231   jresult = result;
73232   return jresult;
73233 }
73234
73235
73236 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
73237   float jresult ;
73238   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73239   float arg2 ;
73240   float result;
73241
73242   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73243   arg2 = (float)jarg2;
73244   {
73245     try {
73246       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
73247     } catch (std::out_of_range& e) {
73248       {
73249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73250       };
73251     } catch (std::exception& e) {
73252       {
73253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73254       };
73255     } catch (Dali::DaliException e) {
73256       {
73257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73258       };
73259     } catch (...) {
73260       {
73261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73262       };
73263     }
73264   }
73265
73266   jresult = result;
73267   return jresult;
73268 }
73269
73270
73271 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73272   float jresult ;
73273   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73274   unsigned int arg2 ;
73275   unsigned int *arg3 = 0 ;
73276   bool arg4 ;
73277   float result;
73278
73279   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73280   arg2 = (unsigned int)jarg2;
73281   arg3 = (unsigned int *)jarg3;
73282   arg4 = jarg4 ? true : false;
73283   {
73284     try {
73285       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73286     } catch (std::out_of_range& e) {
73287       {
73288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73289       };
73290     } catch (std::exception& e) {
73291       {
73292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73293       };
73294     } catch (Dali::DaliException e) {
73295       {
73296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73297       };
73298     } catch (...) {
73299       {
73300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73301       };
73302     }
73303   }
73304
73305   jresult = result;
73306   return jresult;
73307 }
73308
73309
73310 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73311   unsigned int jresult ;
73312   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73313   float arg2 ;
73314   bool arg3 ;
73315   unsigned int result;
73316
73317   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73318   arg2 = (float)jarg2;
73319   arg3 = jarg3 ? true : false;
73320   {
73321     try {
73322       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
73323     } catch (std::out_of_range& e) {
73324       {
73325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (std::exception& e) {
73328       {
73329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73330       };
73331     } catch (Dali::DaliException e) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73334       };
73335     } catch (...) {
73336       {
73337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73338       };
73339     }
73340   }
73341
73342   jresult = result;
73343   return jresult;
73344 }
73345
73346
73347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
73348   unsigned int jresult ;
73349   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73350   unsigned int result;
73351
73352   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73353   {
73354     try {
73355       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
73356     } catch (std::out_of_range& e) {
73357       {
73358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73359       };
73360     } catch (std::exception& e) {
73361       {
73362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73363       };
73364     } catch (Dali::DaliException e) {
73365       {
73366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73367       };
73368     } catch (...) {
73369       {
73370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73371       };
73372     }
73373   }
73374
73375   jresult = result;
73376   return jresult;
73377 }
73378
73379
73380 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
73381   int jresult ;
73382   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73383   Dali::Toolkit::Ruler::RulerType result;
73384
73385   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73386   {
73387     try {
73388       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
73389     } catch (std::out_of_range& e) {
73390       {
73391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73392       };
73393     } catch (std::exception& e) {
73394       {
73395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73396       };
73397     } catch (Dali::DaliException e) {
73398       {
73399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73400       };
73401     } catch (...) {
73402       {
73403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73404       };
73405     }
73406   }
73407
73408   jresult = (int)result;
73409   return jresult;
73410 }
73411
73412
73413 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
73414   unsigned int jresult ;
73415   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73416   bool result;
73417
73418   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73419   {
73420     try {
73421       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
73422     } catch (std::out_of_range& e) {
73423       {
73424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73425       };
73426     } catch (std::exception& e) {
73427       {
73428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73429       };
73430     } catch (Dali::DaliException e) {
73431       {
73432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73433       };
73434     } catch (...) {
73435       {
73436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73437       };
73438     }
73439   }
73440
73441   jresult = result;
73442   return jresult;
73443 }
73444
73445
73446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
73447   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73448
73449   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73450   {
73451     try {
73452       (arg1)->Enable();
73453     } catch (std::out_of_range& e) {
73454       {
73455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73456       };
73457     } catch (std::exception& e) {
73458       {
73459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73460       };
73461     } catch (Dali::DaliException e) {
73462       {
73463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73464       };
73465     } catch (...) {
73466       {
73467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73468       };
73469     }
73470   }
73471
73472 }
73473
73474
73475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
73476   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73477
73478   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73479   {
73480     try {
73481       (arg1)->Disable();
73482     } catch (std::out_of_range& e) {
73483       {
73484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73485       };
73486     } catch (std::exception& e) {
73487       {
73488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73489       };
73490     } catch (Dali::DaliException e) {
73491       {
73492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73493       };
73494     } catch (...) {
73495       {
73496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73497       };
73498     }
73499   }
73500
73501 }
73502
73503
73504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73505   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73506   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73507   Dali::Toolkit::RulerDomain *argp2 ;
73508
73509   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73510   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73511   if (!argp2) {
73512     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73513     return ;
73514   }
73515   arg2 = *argp2;
73516   {
73517     try {
73518       (arg1)->SetDomain(arg2);
73519     } catch (std::out_of_range& e) {
73520       {
73521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73522       };
73523     } catch (std::exception& e) {
73524       {
73525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73526       };
73527     } catch (Dali::DaliException e) {
73528       {
73529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73530       };
73531     } catch (...) {
73532       {
73533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73534       };
73535     }
73536   }
73537
73538 }
73539
73540
73541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73542   void * jresult ;
73543   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73544   Dali::Toolkit::RulerDomain *result = 0 ;
73545
73546   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73547   {
73548     try {
73549       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73550     } catch (std::out_of_range& e) {
73551       {
73552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73553       };
73554     } catch (std::exception& e) {
73555       {
73556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73557       };
73558     } catch (Dali::DaliException e) {
73559       {
73560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73561       };
73562     } catch (...) {
73563       {
73564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73565       };
73566     }
73567   }
73568
73569   jresult = (void *)result;
73570   return jresult;
73571 }
73572
73573
73574 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73575   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73576
73577   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73578   {
73579     try {
73580       (arg1)->DisableDomain();
73581     } catch (std::out_of_range& e) {
73582       {
73583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73584       };
73585     } catch (std::exception& e) {
73586       {
73587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73588       };
73589     } catch (Dali::DaliException e) {
73590       {
73591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73592       };
73593     } catch (...) {
73594       {
73595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73596       };
73597     }
73598   }
73599
73600 }
73601
73602
73603 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73604   float jresult ;
73605   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73606   float arg2 ;
73607   float arg3 ;
73608   float arg4 ;
73609   float result;
73610
73611   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73612   arg2 = (float)jarg2;
73613   arg3 = (float)jarg3;
73614   arg4 = (float)jarg4;
73615   {
73616     try {
73617       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73618     } catch (std::out_of_range& e) {
73619       {
73620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73621       };
73622     } catch (std::exception& e) {
73623       {
73624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73625       };
73626     } catch (Dali::DaliException e) {
73627       {
73628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73629       };
73630     } catch (...) {
73631       {
73632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73633       };
73634     }
73635   }
73636
73637   jresult = result;
73638   return jresult;
73639 }
73640
73641
73642 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73643   float jresult ;
73644   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73645   float arg2 ;
73646   float arg3 ;
73647   float result;
73648
73649   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73650   arg2 = (float)jarg2;
73651   arg3 = (float)jarg3;
73652   {
73653     try {
73654       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73655     } catch (std::out_of_range& e) {
73656       {
73657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73658       };
73659     } catch (std::exception& e) {
73660       {
73661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73662       };
73663     } catch (Dali::DaliException e) {
73664       {
73665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73666       };
73667     } catch (...) {
73668       {
73669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73670       };
73671     }
73672   }
73673
73674   jresult = result;
73675   return jresult;
73676 }
73677
73678
73679 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73680   float jresult ;
73681   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73682   float arg2 ;
73683   float result;
73684
73685   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73686   arg2 = (float)jarg2;
73687   {
73688     try {
73689       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73690     } catch (std::out_of_range& e) {
73691       {
73692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73693       };
73694     } catch (std::exception& e) {
73695       {
73696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73697       };
73698     } catch (Dali::DaliException e) {
73699       {
73700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73701       };
73702     } catch (...) {
73703       {
73704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73705       };
73706     }
73707   }
73708
73709   jresult = result;
73710   return jresult;
73711 }
73712
73713
73714 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73715   float jresult ;
73716   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73717   float arg2 ;
73718   float arg3 ;
73719   float arg4 ;
73720   Dali::Toolkit::ClampState *arg5 = 0 ;
73721   float result;
73722
73723   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73724   arg2 = (float)jarg2;
73725   arg3 = (float)jarg3;
73726   arg4 = (float)jarg4;
73727   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73728   if (!arg5) {
73729     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73730     return 0;
73731   }
73732   {
73733     try {
73734       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73735     } catch (std::out_of_range& e) {
73736       {
73737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73738       };
73739     } catch (std::exception& e) {
73740       {
73741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73742       };
73743     } catch (Dali::DaliException e) {
73744       {
73745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73746       };
73747     } catch (...) {
73748       {
73749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73750       };
73751     }
73752   }
73753
73754   jresult = result;
73755   return jresult;
73756 }
73757
73758
73759 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73760   float jresult ;
73761   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73762   float arg2 ;
73763   float arg3 ;
73764   float arg4 ;
73765   float arg5 ;
73766   float result;
73767
73768   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73769   arg2 = (float)jarg2;
73770   arg3 = (float)jarg3;
73771   arg4 = (float)jarg4;
73772   arg5 = (float)jarg5;
73773   {
73774     try {
73775       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73776     } catch (std::out_of_range& e) {
73777       {
73778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73779       };
73780     } catch (std::exception& e) {
73781       {
73782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73783       };
73784     } catch (Dali::DaliException e) {
73785       {
73786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73787       };
73788     } catch (...) {
73789       {
73790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73791       };
73792     }
73793   }
73794
73795   jresult = result;
73796   return jresult;
73797 }
73798
73799
73800 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73801   float jresult ;
73802   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73803   float arg2 ;
73804   float arg3 ;
73805   float arg4 ;
73806   float result;
73807
73808   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73809   arg2 = (float)jarg2;
73810   arg3 = (float)jarg3;
73811   arg4 = (float)jarg4;
73812   {
73813     try {
73814       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73815     } catch (std::out_of_range& e) {
73816       {
73817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73818       };
73819     } catch (std::exception& e) {
73820       {
73821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73822       };
73823     } catch (Dali::DaliException e) {
73824       {
73825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73826       };
73827     } catch (...) {
73828       {
73829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73830       };
73831     }
73832   }
73833
73834   jresult = result;
73835   return jresult;
73836 }
73837
73838
73839 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73840   float jresult ;
73841   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73842   float arg2 ;
73843   float arg3 ;
73844   float result;
73845
73846   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73847   arg2 = (float)jarg2;
73848   arg3 = (float)jarg3;
73849   {
73850     try {
73851       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
73852     } catch (std::out_of_range& e) {
73853       {
73854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73855       };
73856     } catch (std::exception& e) {
73857       {
73858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73859       };
73860     } catch (Dali::DaliException e) {
73861       {
73862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73863       };
73864     } catch (...) {
73865       {
73866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73867       };
73868     }
73869   }
73870
73871   jresult = result;
73872   return jresult;
73873 }
73874
73875
73876 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73877   float jresult ;
73878   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73879   float arg2 ;
73880   float result;
73881
73882   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73883   arg2 = (float)jarg2;
73884   {
73885     try {
73886       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73887     } catch (std::out_of_range& e) {
73888       {
73889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73890       };
73891     } catch (std::exception& e) {
73892       {
73893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73894       };
73895     } catch (Dali::DaliException e) {
73896       {
73897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73898       };
73899     } catch (...) {
73900       {
73901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73902       };
73903     }
73904   }
73905
73906   jresult = result;
73907   return jresult;
73908 }
73909
73910
73911 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73912   float jresult ;
73913   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73914   float arg2 ;
73915   float arg3 ;
73916   float arg4 ;
73917   float arg5 ;
73918   Dali::Toolkit::ClampState *arg6 = 0 ;
73919   float result;
73920
73921   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73922   arg2 = (float)jarg2;
73923   arg3 = (float)jarg3;
73924   arg4 = (float)jarg4;
73925   arg5 = (float)jarg5;
73926   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73927   if (!arg6) {
73928     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73929     return 0;
73930   }
73931   {
73932     try {
73933       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73934     } catch (std::out_of_range& e) {
73935       {
73936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73937       };
73938     } catch (std::exception& e) {
73939       {
73940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73941       };
73942     } catch (Dali::DaliException e) {
73943       {
73944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73945       };
73946     } catch (...) {
73947       {
73948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73949       };
73950     }
73951   }
73952
73953   jresult = result;
73954   return jresult;
73955 }
73956
73957
73958 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73959   void * jresult ;
73960   Dali::Toolkit::DefaultRuler *result = 0 ;
73961
73962   {
73963     try {
73964       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73965     } catch (std::out_of_range& e) {
73966       {
73967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73968       };
73969     } catch (std::exception& e) {
73970       {
73971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73972       };
73973     } catch (Dali::DaliException e) {
73974       {
73975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73976       };
73977     } catch (...) {
73978       {
73979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73980       };
73981     }
73982   }
73983
73984   jresult = (void *)result;
73985   return jresult;
73986 }
73987
73988
73989 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73990   float jresult ;
73991   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73992   float arg2 ;
73993   float arg3 ;
73994   float result;
73995
73996   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73997   arg2 = (float)jarg2;
73998   arg3 = (float)jarg3;
73999   {
74000     try {
74001       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
74002     } catch (std::out_of_range& e) {
74003       {
74004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74005       };
74006     } catch (std::exception& e) {
74007       {
74008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74009       };
74010     } catch (Dali::DaliException e) {
74011       {
74012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74013       };
74014     } catch (...) {
74015       {
74016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74017       };
74018     }
74019   }
74020
74021   jresult = result;
74022   return jresult;
74023 }
74024
74025
74026 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74027   float jresult ;
74028   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74029   unsigned int arg2 ;
74030   unsigned int *arg3 = 0 ;
74031   bool arg4 ;
74032   float result;
74033
74034   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74035   arg2 = (unsigned int)jarg2;
74036   arg3 = (unsigned int *)jarg3;
74037   arg4 = jarg4 ? true : false;
74038   {
74039     try {
74040       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74041     } catch (std::out_of_range& e) {
74042       {
74043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74044       };
74045     } catch (std::exception& e) {
74046       {
74047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74048       };
74049     } catch (Dali::DaliException e) {
74050       {
74051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74052       };
74053     } catch (...) {
74054       {
74055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74056       };
74057     }
74058   }
74059
74060   jresult = result;
74061   return jresult;
74062 }
74063
74064
74065 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74066   unsigned int jresult ;
74067   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74068   float arg2 ;
74069   bool arg3 ;
74070   unsigned int result;
74071
74072   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74073   arg2 = (float)jarg2;
74074   arg3 = jarg3 ? true : false;
74075   {
74076     try {
74077       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74078     } catch (std::out_of_range& e) {
74079       {
74080         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74081       };
74082     } catch (std::exception& e) {
74083       {
74084         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74085       };
74086     } catch (Dali::DaliException e) {
74087       {
74088         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74089       };
74090     } catch (...) {
74091       {
74092         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74093       };
74094     }
74095   }
74096
74097   jresult = result;
74098   return jresult;
74099 }
74100
74101
74102 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
74103   unsigned int jresult ;
74104   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74105   unsigned int result;
74106
74107   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74108   {
74109     try {
74110       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
74111     } catch (std::out_of_range& e) {
74112       {
74113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74114       };
74115     } catch (std::exception& e) {
74116       {
74117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74118       };
74119     } catch (Dali::DaliException e) {
74120       {
74121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74122       };
74123     } catch (...) {
74124       {
74125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74126       };
74127     }
74128   }
74129
74130   jresult = result;
74131   return jresult;
74132 }
74133
74134
74135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
74136   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
74137
74138   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
74139   {
74140     try {
74141       delete arg1;
74142     } catch (std::out_of_range& e) {
74143       {
74144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74145       };
74146     } catch (std::exception& e) {
74147       {
74148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74149       };
74150     } catch (Dali::DaliException e) {
74151       {
74152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74153       };
74154     } catch (...) {
74155       {
74156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74157       };
74158     }
74159   }
74160
74161 }
74162
74163
74164 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
74165   void * jresult ;
74166   float arg1 ;
74167   Dali::Toolkit::FixedRuler *result = 0 ;
74168
74169   arg1 = (float)jarg1;
74170   {
74171     try {
74172       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
74173     } catch (std::out_of_range& e) {
74174       {
74175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74176       };
74177     } catch (std::exception& e) {
74178       {
74179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74180       };
74181     } catch (Dali::DaliException e) {
74182       {
74183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74184       };
74185     } catch (...) {
74186       {
74187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74188       };
74189     }
74190   }
74191
74192   jresult = (void *)result;
74193   return jresult;
74194 }
74195
74196
74197 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
74198   void * jresult ;
74199   Dali::Toolkit::FixedRuler *result = 0 ;
74200
74201   {
74202     try {
74203       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
74204     } catch (std::out_of_range& e) {
74205       {
74206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74207       };
74208     } catch (std::exception& e) {
74209       {
74210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74211       };
74212     } catch (Dali::DaliException e) {
74213       {
74214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74215       };
74216     } catch (...) {
74217       {
74218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74219       };
74220     }
74221   }
74222
74223   jresult = (void *)result;
74224   return jresult;
74225 }
74226
74227
74228 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
74229   float jresult ;
74230   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74231   float arg2 ;
74232   float arg3 ;
74233   float result;
74234
74235   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74236   arg2 = (float)jarg2;
74237   arg3 = (float)jarg3;
74238   {
74239     try {
74240       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
74241     } catch (std::out_of_range& e) {
74242       {
74243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74244       };
74245     } catch (std::exception& e) {
74246       {
74247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74248       };
74249     } catch (Dali::DaliException e) {
74250       {
74251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74252       };
74253     } catch (...) {
74254       {
74255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74256       };
74257     }
74258   }
74259
74260   jresult = result;
74261   return jresult;
74262 }
74263
74264
74265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
74266   float jresult ;
74267   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74268   unsigned int arg2 ;
74269   unsigned int *arg3 = 0 ;
74270   bool arg4 ;
74271   float result;
74272
74273   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74274   arg2 = (unsigned int)jarg2;
74275   arg3 = (unsigned int *)jarg3;
74276   arg4 = jarg4 ? true : false;
74277   {
74278     try {
74279       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
74280     } catch (std::out_of_range& e) {
74281       {
74282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74283       };
74284     } catch (std::exception& e) {
74285       {
74286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74287       };
74288     } catch (Dali::DaliException e) {
74289       {
74290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74291       };
74292     } catch (...) {
74293       {
74294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74295       };
74296     }
74297   }
74298
74299   jresult = result;
74300   return jresult;
74301 }
74302
74303
74304 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
74305   unsigned int jresult ;
74306   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74307   float arg2 ;
74308   bool arg3 ;
74309   unsigned int result;
74310
74311   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74312   arg2 = (float)jarg2;
74313   arg3 = jarg3 ? true : false;
74314   {
74315     try {
74316       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
74317     } catch (std::out_of_range& e) {
74318       {
74319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74320       };
74321     } catch (std::exception& e) {
74322       {
74323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74324       };
74325     } catch (Dali::DaliException e) {
74326       {
74327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74328       };
74329     } catch (...) {
74330       {
74331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74332       };
74333     }
74334   }
74335
74336   jresult = result;
74337   return jresult;
74338 }
74339
74340
74341 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
74342   unsigned int jresult ;
74343   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74344   unsigned int result;
74345
74346   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74347   {
74348     try {
74349       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
74350     } catch (std::out_of_range& e) {
74351       {
74352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74353       };
74354     } catch (std::exception& e) {
74355       {
74356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74357       };
74358     } catch (Dali::DaliException e) {
74359       {
74360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74361       };
74362     } catch (...) {
74363       {
74364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74365       };
74366     }
74367   }
74368
74369   jresult = result;
74370   return jresult;
74371 }
74372
74373
74374 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
74375   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
74376
74377   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
74378   {
74379     try {
74380       delete arg1;
74381     } catch (std::out_of_range& e) {
74382       {
74383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74384       };
74385     } catch (std::exception& e) {
74386       {
74387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74388       };
74389     } catch (Dali::DaliException e) {
74390       {
74391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74392       };
74393     } catch (...) {
74394       {
74395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74396       };
74397     }
74398   }
74399
74400 }
74401
74402
74403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
74404   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74405   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74406
74407   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74408   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74409   if (arg1) (arg1)->scale = *arg2;
74410 }
74411
74412
74413 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
74414   void * jresult ;
74415   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74416   Dali::Toolkit::ClampState2D *result = 0 ;
74417
74418   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74419   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
74420   jresult = (void *)result;
74421   return jresult;
74422 }
74423
74424
74425 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
74426   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74427   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
74428
74429   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74430   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
74431   if (arg1) (arg1)->position = *arg2;
74432 }
74433
74434
74435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
74436   void * jresult ;
74437   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74438   Dali::Toolkit::ClampState2D *result = 0 ;
74439
74440   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74441   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
74442   jresult = (void *)result;
74443   return jresult;
74444 }
74445
74446
74447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
74448   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74449   Dali::Toolkit::ClampState arg2 ;
74450
74451   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74452   arg2 = (Dali::Toolkit::ClampState)jarg2;
74453   if (arg1) (arg1)->rotation = arg2;
74454 }
74455
74456
74457 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
74458   int jresult ;
74459   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74460   Dali::Toolkit::ClampState result;
74461
74462   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74463   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
74464   jresult = (int)result;
74465   return jresult;
74466 }
74467
74468
74469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
74470   void * jresult ;
74471   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
74472
74473   {
74474     try {
74475       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
74476     } catch (std::out_of_range& e) {
74477       {
74478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74479       };
74480     } catch (std::exception& e) {
74481       {
74482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74483       };
74484     } catch (Dali::DaliException e) {
74485       {
74486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74487       };
74488     } catch (...) {
74489       {
74490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74491       };
74492     }
74493   }
74494
74495   jresult = (void *)result;
74496   return jresult;
74497 }
74498
74499
74500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74501   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74502
74503   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74504   {
74505     try {
74506       delete arg1;
74507     } catch (std::out_of_range& e) {
74508       {
74509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74510       };
74511     } catch (std::exception& e) {
74512       {
74513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74514       };
74515     } catch (Dali::DaliException e) {
74516       {
74517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74518       };
74519     } catch (...) {
74520       {
74521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74522       };
74523     }
74524   }
74525
74526 }
74527
74528
74529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74530   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74531   Dali::Toolkit::SnapType arg2 ;
74532
74533   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74534   arg2 = (Dali::Toolkit::SnapType)jarg2;
74535   if (arg1) (arg1)->type = arg2;
74536 }
74537
74538
74539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74540   int jresult ;
74541   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74542   Dali::Toolkit::SnapType result;
74543
74544   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74545   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74546   jresult = (int)result;
74547   return jresult;
74548 }
74549
74550
74551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74552   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74553   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74554
74555   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74556   arg2 = (Dali::Vector2 *)jarg2;
74557   if (arg1) (arg1)->position = *arg2;
74558 }
74559
74560
74561 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74562   void * jresult ;
74563   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74564   Dali::Vector2 *result = 0 ;
74565
74566   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74567   result = (Dali::Vector2 *)& ((arg1)->position);
74568   jresult = (void *)result;
74569   return jresult;
74570 }
74571
74572
74573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74574   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74575   float arg2 ;
74576
74577   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74578   arg2 = (float)jarg2;
74579   if (arg1) (arg1)->duration = arg2;
74580 }
74581
74582
74583 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74584   float jresult ;
74585   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74586   float result;
74587
74588   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74589   result = (float) ((arg1)->duration);
74590   jresult = result;
74591   return jresult;
74592 }
74593
74594
74595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74596   void * jresult ;
74597   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74598
74599   {
74600     try {
74601       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74602     } catch (std::out_of_range& e) {
74603       {
74604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74605       };
74606     } catch (std::exception& e) {
74607       {
74608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74609       };
74610     } catch (Dali::DaliException e) {
74611       {
74612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74613       };
74614     } catch (...) {
74615       {
74616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74617       };
74618     }
74619   }
74620
74621   jresult = (void *)result;
74622   return jresult;
74623 }
74624
74625
74626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74627   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74628
74629   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74630   {
74631     try {
74632       delete arg1;
74633     } catch (std::out_of_range& e) {
74634       {
74635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74636       };
74637     } catch (std::exception& e) {
74638       {
74639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74640       };
74641     } catch (Dali::DaliException e) {
74642       {
74643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74644       };
74645     } catch (...) {
74646       {
74647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74648       };
74649     }
74650   }
74651
74652 }
74653
74654
74655 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74656   int jresult ;
74657   int result;
74658
74659   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74660   jresult = (int)result;
74661   return jresult;
74662 }
74663
74664
74665 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74666   int jresult ;
74667   int result;
74668
74669   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74670   jresult = (int)result;
74671   return jresult;
74672 }
74673
74674
74675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74676   int jresult ;
74677   int result;
74678
74679   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74680   jresult = (int)result;
74681   return jresult;
74682 }
74683
74684
74685 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74686   int jresult ;
74687   int result;
74688
74689   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74690   jresult = (int)result;
74691   return jresult;
74692 }
74693
74694
74695 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74696   int jresult ;
74697   int result;
74698
74699   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74700   jresult = (int)result;
74701   return jresult;
74702 }
74703
74704 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74705   int jresult ;
74706   int result;
74707
74708   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74709   jresult = (int)result;
74710   return jresult;
74711 }
74712
74713
74714 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74715   int jresult ;
74716   int result;
74717
74718   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74719   jresult = (int)result;
74720   return jresult;
74721 }
74722
74723
74724 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74725   int jresult ;
74726   int result;
74727
74728   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74729   jresult = (int)result;
74730   return jresult;
74731 }
74732
74733
74734 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74735   int jresult ;
74736   int result;
74737
74738   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74739   jresult = (int)result;
74740   return jresult;
74741 }
74742
74743
74744 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74745   int jresult ;
74746   int result;
74747
74748   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74749   jresult = (int)result;
74750   return jresult;
74751 }
74752
74753
74754 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74755   int jresult ;
74756   int result;
74757
74758   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74759   jresult = (int)result;
74760   return jresult;
74761 }
74762
74763
74764 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74765   int jresult ;
74766   int result;
74767
74768   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74769   jresult = (int)result;
74770   return jresult;
74771 }
74772
74773
74774 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74775   int jresult ;
74776   int result;
74777
74778   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74779   jresult = (int)result;
74780   return jresult;
74781 }
74782
74783
74784 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74785   int jresult ;
74786   int result;
74787
74788   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74789   jresult = (int)result;
74790   return jresult;
74791 }
74792
74793
74794 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74795   int jresult ;
74796   int result;
74797
74798   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74799   jresult = (int)result;
74800   return jresult;
74801 }
74802
74803
74804 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74805   int jresult ;
74806   int result;
74807
74808   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74809   jresult = (int)result;
74810   return jresult;
74811 }
74812
74813
74814 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74815   int jresult ;
74816   int result;
74817
74818   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74819   jresult = (int)result;
74820   return jresult;
74821 }
74822
74823
74824 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74825   int jresult ;
74826   int result;
74827
74828   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74829   jresult = (int)result;
74830   return jresult;
74831 }
74832
74833
74834 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74835   int jresult ;
74836   int result;
74837
74838   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74839   jresult = (int)result;
74840   return jresult;
74841 }
74842
74843
74844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74845   int jresult ;
74846   int result;
74847
74848   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74849   jresult = (int)result;
74850   return jresult;
74851 }
74852
74853
74854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74855   int jresult ;
74856   int result;
74857
74858   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74859   jresult = (int)result;
74860   return jresult;
74861 }
74862
74863
74864 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74865   int jresult ;
74866   int result;
74867
74868   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74869   jresult = (int)result;
74870   return jresult;
74871 }
74872
74873
74874 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74875   int jresult ;
74876   int result;
74877
74878   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74879   jresult = (int)result;
74880   return jresult;
74881 }
74882
74883
74884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74885   int jresult ;
74886   int result;
74887
74888   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74889   jresult = (int)result;
74890   return jresult;
74891 }
74892
74893
74894 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74895   int jresult ;
74896   int result;
74897
74898   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74899   jresult = (int)result;
74900   return jresult;
74901 }
74902
74903
74904 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74905   int jresult ;
74906   int result;
74907
74908   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74909   jresult = (int)result;
74910   return jresult;
74911 }
74912
74913
74914 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74915   void * jresult ;
74916   Dali::Toolkit::ScrollView::Property *result = 0 ;
74917
74918   {
74919     try {
74920       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74921     } catch (std::out_of_range& e) {
74922       {
74923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74924       };
74925     } catch (std::exception& e) {
74926       {
74927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74928       };
74929     } catch (Dali::DaliException e) {
74930       {
74931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74932       };
74933     } catch (...) {
74934       {
74935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74936       };
74937     }
74938   }
74939
74940   jresult = (void *)result;
74941   return jresult;
74942 }
74943
74944
74945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74946   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74947
74948   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74949   {
74950     try {
74951       delete arg1;
74952     } catch (std::out_of_range& e) {
74953       {
74954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74955       };
74956     } catch (std::exception& e) {
74957       {
74958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74959       };
74960     } catch (Dali::DaliException e) {
74961       {
74962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74963       };
74964     } catch (...) {
74965       {
74966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74967       };
74968     }
74969   }
74970
74971 }
74972
74973
74974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74975   void * jresult ;
74976   Dali::Toolkit::ScrollView *result = 0 ;
74977
74978   {
74979     try {
74980       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74981     } catch (std::out_of_range& e) {
74982       {
74983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74984       };
74985     } catch (std::exception& e) {
74986       {
74987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74988       };
74989     } catch (Dali::DaliException e) {
74990       {
74991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74992       };
74993     } catch (...) {
74994       {
74995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74996       };
74997     }
74998   }
74999
75000   jresult = (void *)result;
75001   return jresult;
75002 }
75003
75004
75005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
75006   void * jresult ;
75007   Dali::Toolkit::ScrollView *arg1 = 0 ;
75008   Dali::Toolkit::ScrollView *result = 0 ;
75009
75010   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75011   if (!arg1) {
75012     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
75013     return 0;
75014   }
75015   {
75016     try {
75017       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
75018     } catch (std::out_of_range& e) {
75019       {
75020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75021       };
75022     } catch (std::exception& e) {
75023       {
75024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75025       };
75026     } catch (Dali::DaliException e) {
75027       {
75028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75029       };
75030     } catch (...) {
75031       {
75032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75033       };
75034     }
75035   }
75036
75037   jresult = (void *)result;
75038   return jresult;
75039 }
75040
75041
75042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
75043   void * jresult ;
75044   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75045   Dali::Toolkit::ScrollView *arg2 = 0 ;
75046   Dali::Toolkit::ScrollView *result = 0 ;
75047
75048   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75049   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
75050   if (!arg2) {
75051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
75052     return 0;
75053   }
75054   {
75055     try {
75056       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
75057     } catch (std::out_of_range& e) {
75058       {
75059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75060       };
75061     } catch (std::exception& e) {
75062       {
75063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75064       };
75065     } catch (Dali::DaliException e) {
75066       {
75067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75068       };
75069     } catch (...) {
75070       {
75071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75072       };
75073     }
75074   }
75075
75076   jresult = (void *)result;
75077   return jresult;
75078 }
75079
75080
75081 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
75082   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75083
75084   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75085   {
75086     try {
75087       delete arg1;
75088     } catch (std::out_of_range& e) {
75089       {
75090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75091       };
75092     } catch (std::exception& e) {
75093       {
75094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75095       };
75096     } catch (Dali::DaliException e) {
75097       {
75098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75099       };
75100     } catch (...) {
75101       {
75102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75103       };
75104     }
75105   }
75106
75107 }
75108
75109
75110 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
75111   void * jresult ;
75112   Dali::Toolkit::ScrollView result;
75113
75114   {
75115     try {
75116       result = Dali::Toolkit::ScrollView::New();
75117     } catch (std::out_of_range& e) {
75118       {
75119         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75120       };
75121     } catch (std::exception& e) {
75122       {
75123         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75124       };
75125     } catch (Dali::DaliException e) {
75126       {
75127         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75128       };
75129     } catch (...) {
75130       {
75131         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75132       };
75133     }
75134   }
75135
75136   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
75137   return jresult;
75138 }
75139
75140
75141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
75142   void * jresult ;
75143   Dali::BaseHandle arg1 ;
75144   Dali::BaseHandle *argp1 ;
75145   Dali::Toolkit::ScrollView result;
75146
75147   argp1 = (Dali::BaseHandle *)jarg1;
75148   if (!argp1) {
75149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
75150     return 0;
75151   }
75152   arg1 = *argp1;
75153   {
75154     try {
75155       result = Dali::Toolkit::ScrollView::DownCast(arg1);
75156     } catch (std::out_of_range& e) {
75157       {
75158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75159       };
75160     } catch (std::exception& e) {
75161       {
75162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75163       };
75164     } catch (Dali::DaliException e) {
75165       {
75166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75167       };
75168     } catch (...) {
75169       {
75170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75171       };
75172     }
75173   }
75174
75175   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
75176   return jresult;
75177 }
75178
75179
75180 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
75181   void * jresult ;
75182   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75183   Dali::AlphaFunction result;
75184
75185   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75186   {
75187     try {
75188       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
75189     } catch (std::out_of_range& e) {
75190       {
75191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75192       };
75193     } catch (std::exception& e) {
75194       {
75195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75196       };
75197     } catch (Dali::DaliException e) {
75198       {
75199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75200       };
75201     } catch (...) {
75202       {
75203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75204       };
75205     }
75206   }
75207
75208   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75209   return jresult;
75210 }
75211
75212
75213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
75214   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75215   Dali::AlphaFunction arg2 ;
75216   Dali::AlphaFunction *argp2 ;
75217
75218   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75219   argp2 = (Dali::AlphaFunction *)jarg2;
75220   if (!argp2) {
75221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75222     return ;
75223   }
75224   arg2 = *argp2;
75225   {
75226     try {
75227       (arg1)->SetScrollSnapAlphaFunction(arg2);
75228     } catch (std::out_of_range& e) {
75229       {
75230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75231       };
75232     } catch (std::exception& e) {
75233       {
75234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75235       };
75236     } catch (Dali::DaliException e) {
75237       {
75238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75239       };
75240     } catch (...) {
75241       {
75242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75243       };
75244     }
75245   }
75246
75247 }
75248
75249
75250 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
75251   void * jresult ;
75252   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75253   Dali::AlphaFunction result;
75254
75255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75256   {
75257     try {
75258       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
75259     } catch (std::out_of_range& e) {
75260       {
75261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75262       };
75263     } catch (std::exception& e) {
75264       {
75265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75266       };
75267     } catch (Dali::DaliException e) {
75268       {
75269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75270       };
75271     } catch (...) {
75272       {
75273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75274       };
75275     }
75276   }
75277
75278   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
75279   return jresult;
75280 }
75281
75282
75283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
75284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75285   Dali::AlphaFunction arg2 ;
75286   Dali::AlphaFunction *argp2 ;
75287
75288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75289   argp2 = (Dali::AlphaFunction *)jarg2;
75290   if (!argp2) {
75291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75292     return ;
75293   }
75294   arg2 = *argp2;
75295   {
75296     try {
75297       (arg1)->SetScrollFlickAlphaFunction(arg2);
75298     } catch (std::out_of_range& e) {
75299       {
75300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75301       };
75302     } catch (std::exception& e) {
75303       {
75304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75305       };
75306     } catch (Dali::DaliException e) {
75307       {
75308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75309       };
75310     } catch (...) {
75311       {
75312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75313       };
75314     }
75315   }
75316
75317 }
75318
75319
75320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
75321   float jresult ;
75322   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75323   float result;
75324
75325   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75326   {
75327     try {
75328       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
75329     } catch (std::out_of_range& e) {
75330       {
75331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75332       };
75333     } catch (std::exception& e) {
75334       {
75335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75336       };
75337     } catch (Dali::DaliException e) {
75338       {
75339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75340       };
75341     } catch (...) {
75342       {
75343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75344       };
75345     }
75346   }
75347
75348   jresult = result;
75349   return jresult;
75350 }
75351
75352
75353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
75354   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75355   float arg2 ;
75356
75357   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75358   arg2 = (float)jarg2;
75359   {
75360     try {
75361       (arg1)->SetScrollSnapDuration(arg2);
75362     } catch (std::out_of_range& e) {
75363       {
75364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75365       };
75366     } catch (std::exception& e) {
75367       {
75368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75369       };
75370     } catch (Dali::DaliException e) {
75371       {
75372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75373       };
75374     } catch (...) {
75375       {
75376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75377       };
75378     }
75379   }
75380
75381 }
75382
75383
75384 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
75385   float jresult ;
75386   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75387   float result;
75388
75389   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75390   {
75391     try {
75392       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
75393     } catch (std::out_of_range& e) {
75394       {
75395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75396       };
75397     } catch (std::exception& e) {
75398       {
75399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75400       };
75401     } catch (Dali::DaliException e) {
75402       {
75403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75404       };
75405     } catch (...) {
75406       {
75407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75408       };
75409     }
75410   }
75411
75412   jresult = result;
75413   return jresult;
75414 }
75415
75416
75417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
75418   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75419   float arg2 ;
75420
75421   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75422   arg2 = (float)jarg2;
75423   {
75424     try {
75425       (arg1)->SetScrollFlickDuration(arg2);
75426     } catch (std::out_of_range& e) {
75427       {
75428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75429       };
75430     } catch (std::exception& e) {
75431       {
75432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75433       };
75434     } catch (Dali::DaliException e) {
75435       {
75436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75437       };
75438     } catch (...) {
75439       {
75440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75441       };
75442     }
75443   }
75444
75445 }
75446
75447
75448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
75449   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75450   Dali::Toolkit::RulerPtr arg2 ;
75451   Dali::Toolkit::RulerPtr *argp2 ;
75452
75453   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75454   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75455   if (!argp2) {
75456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75457     return ;
75458   }
75459   arg2 = *argp2;
75460   {
75461     try {
75462       (arg1)->SetRulerX(arg2);
75463     } catch (std::out_of_range& e) {
75464       {
75465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75466       };
75467     } catch (std::exception& e) {
75468       {
75469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75470       };
75471     } catch (Dali::DaliException e) {
75472       {
75473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75474       };
75475     } catch (...) {
75476       {
75477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75478       };
75479     }
75480   }
75481
75482 }
75483
75484
75485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
75486   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75487   Dali::Toolkit::RulerPtr arg2 ;
75488   Dali::Toolkit::RulerPtr *argp2 ;
75489
75490   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75491   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
75492   if (!argp2) {
75493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
75494     return ;
75495   }
75496   arg2 = *argp2;
75497   {
75498     try {
75499       (arg1)->SetRulerY(arg2);
75500     } catch (std::out_of_range& e) {
75501       {
75502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75503       };
75504     } catch (std::exception& e) {
75505       {
75506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75507       };
75508     } catch (Dali::DaliException e) {
75509       {
75510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75511       };
75512     } catch (...) {
75513       {
75514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75515       };
75516     }
75517   }
75518
75519 }
75520
75521
75522 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75523   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75524   bool arg2 ;
75525
75526   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75527   arg2 = jarg2 ? true : false;
75528   {
75529     try {
75530       (arg1)->SetScrollSensitive(arg2);
75531     } catch (std::out_of_range& e) {
75532       {
75533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75534       };
75535     } catch (std::exception& e) {
75536       {
75537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75538       };
75539     } catch (Dali::DaliException e) {
75540       {
75541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75542       };
75543     } catch (...) {
75544       {
75545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75546       };
75547     }
75548   }
75549
75550 }
75551
75552
75553 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75554   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75555   float arg2 ;
75556   float arg3 ;
75557
75558   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75559   arg2 = (float)jarg2;
75560   arg3 = (float)jarg3;
75561   {
75562     try {
75563       (arg1)->SetMaxOvershoot(arg2,arg3);
75564     } catch (std::out_of_range& e) {
75565       {
75566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75567       };
75568     } catch (std::exception& e) {
75569       {
75570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75571       };
75572     } catch (Dali::DaliException e) {
75573       {
75574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75575       };
75576     } catch (...) {
75577       {
75578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75579       };
75580     }
75581   }
75582
75583 }
75584
75585
75586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75587   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75588   Dali::AlphaFunction arg2 ;
75589   Dali::AlphaFunction *argp2 ;
75590
75591   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75592   argp2 = (Dali::AlphaFunction *)jarg2;
75593   if (!argp2) {
75594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75595     return ;
75596   }
75597   arg2 = *argp2;
75598   {
75599     try {
75600       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75601     } catch (std::out_of_range& e) {
75602       {
75603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75604       };
75605     } catch (std::exception& e) {
75606       {
75607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75608       };
75609     } catch (Dali::DaliException e) {
75610       {
75611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75612       };
75613     } catch (...) {
75614       {
75615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75616       };
75617     }
75618   }
75619
75620 }
75621
75622
75623 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75624   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75625   float arg2 ;
75626
75627   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75628   arg2 = (float)jarg2;
75629   {
75630     try {
75631       (arg1)->SetSnapOvershootDuration(arg2);
75632     } catch (std::out_of_range& e) {
75633       {
75634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75635       };
75636     } catch (std::exception& e) {
75637       {
75638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75639       };
75640     } catch (Dali::DaliException e) {
75641       {
75642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75643       };
75644     } catch (...) {
75645       {
75646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75647       };
75648     }
75649   }
75650
75651 }
75652
75653
75654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75655   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75656   bool arg2 ;
75657
75658   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75659   arg2 = jarg2 ? true : false;
75660   {
75661     try {
75662       (arg1)->SetActorAutoSnap(arg2);
75663     } catch (std::out_of_range& e) {
75664       {
75665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75666       };
75667     } catch (std::exception& e) {
75668       {
75669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75670       };
75671     } catch (Dali::DaliException e) {
75672       {
75673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75674       };
75675     } catch (...) {
75676       {
75677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75678       };
75679     }
75680   }
75681
75682 }
75683
75684
75685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75686   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75687   bool arg2 ;
75688
75689   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75690   arg2 = jarg2 ? true : false;
75691   {
75692     try {
75693       (arg1)->SetWrapMode(arg2);
75694     } catch (std::out_of_range& e) {
75695       {
75696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75697       };
75698     } catch (std::exception& e) {
75699       {
75700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75701       };
75702     } catch (Dali::DaliException e) {
75703       {
75704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75705       };
75706     } catch (...) {
75707       {
75708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75709       };
75710     }
75711   }
75712
75713 }
75714
75715
75716 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75717   int jresult ;
75718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75719   int result;
75720
75721   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75722   {
75723     try {
75724       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75725     } catch (std::out_of_range& e) {
75726       {
75727         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75728       };
75729     } catch (std::exception& e) {
75730       {
75731         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75732       };
75733     } catch (Dali::DaliException e) {
75734       {
75735         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75736       };
75737     } catch (...) {
75738       {
75739         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75740       };
75741     }
75742   }
75743
75744   jresult = result;
75745   return jresult;
75746 }
75747
75748
75749 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75750   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75751   int arg2 ;
75752
75753   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75754   arg2 = (int)jarg2;
75755   {
75756     try {
75757       (arg1)->SetScrollUpdateDistance(arg2);
75758     } catch (std::out_of_range& e) {
75759       {
75760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75761       };
75762     } catch (std::exception& e) {
75763       {
75764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75765       };
75766     } catch (Dali::DaliException e) {
75767       {
75768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75769       };
75770     } catch (...) {
75771       {
75772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75773       };
75774     }
75775   }
75776
75777 }
75778
75779
75780 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75781   unsigned int jresult ;
75782   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75783   bool result;
75784
75785   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75786   {
75787     try {
75788       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75789     } catch (std::out_of_range& e) {
75790       {
75791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75792       };
75793     } catch (std::exception& e) {
75794       {
75795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75796       };
75797     } catch (Dali::DaliException e) {
75798       {
75799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75800       };
75801     } catch (...) {
75802       {
75803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75804       };
75805     }
75806   }
75807
75808   jresult = result;
75809   return jresult;
75810 }
75811
75812
75813 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75814   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75815   bool arg2 ;
75816
75817   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75818   arg2 = jarg2 ? true : false;
75819   {
75820     try {
75821       (arg1)->SetAxisAutoLock(arg2);
75822     } catch (std::out_of_range& e) {
75823       {
75824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75825       };
75826     } catch (std::exception& e) {
75827       {
75828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75829       };
75830     } catch (Dali::DaliException e) {
75831       {
75832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75833       };
75834     } catch (...) {
75835       {
75836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75837       };
75838     }
75839   }
75840
75841 }
75842
75843
75844 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75845   float jresult ;
75846   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75847   float result;
75848
75849   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75850   {
75851     try {
75852       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75853     } catch (std::out_of_range& e) {
75854       {
75855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75856       };
75857     } catch (std::exception& e) {
75858       {
75859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75860       };
75861     } catch (Dali::DaliException e) {
75862       {
75863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75864       };
75865     } catch (...) {
75866       {
75867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75868       };
75869     }
75870   }
75871
75872   jresult = result;
75873   return jresult;
75874 }
75875
75876
75877 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75878   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75879   float arg2 ;
75880
75881   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75882   arg2 = (float)jarg2;
75883   {
75884     try {
75885       (arg1)->SetAxisAutoLockGradient(arg2);
75886     } catch (std::out_of_range& e) {
75887       {
75888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75889       };
75890     } catch (std::exception& e) {
75891       {
75892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75893       };
75894     } catch (Dali::DaliException e) {
75895       {
75896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75897       };
75898     } catch (...) {
75899       {
75900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75901       };
75902     }
75903   }
75904
75905 }
75906
75907
75908 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75909   float jresult ;
75910   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75911   float result;
75912
75913   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75914   {
75915     try {
75916       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75917     } catch (std::out_of_range& e) {
75918       {
75919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75920       };
75921     } catch (std::exception& e) {
75922       {
75923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75924       };
75925     } catch (Dali::DaliException e) {
75926       {
75927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75928       };
75929     } catch (...) {
75930       {
75931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75932       };
75933     }
75934   }
75935
75936   jresult = result;
75937   return jresult;
75938 }
75939
75940
75941 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75942   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75943   float arg2 ;
75944
75945   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75946   arg2 = (float)jarg2;
75947   {
75948     try {
75949       (arg1)->SetFrictionCoefficient(arg2);
75950     } catch (std::out_of_range& e) {
75951       {
75952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75953       };
75954     } catch (std::exception& e) {
75955       {
75956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75957       };
75958     } catch (Dali::DaliException e) {
75959       {
75960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75961       };
75962     } catch (...) {
75963       {
75964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75965       };
75966     }
75967   }
75968
75969 }
75970
75971
75972 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75973   float jresult ;
75974   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75975   float result;
75976
75977   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75978   {
75979     try {
75980       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75981     } catch (std::out_of_range& e) {
75982       {
75983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75984       };
75985     } catch (std::exception& e) {
75986       {
75987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75988       };
75989     } catch (Dali::DaliException e) {
75990       {
75991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75992       };
75993     } catch (...) {
75994       {
75995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75996       };
75997     }
75998   }
75999
76000   jresult = result;
76001   return jresult;
76002 }
76003
76004
76005 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
76006   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76007   float arg2 ;
76008
76009   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76010   arg2 = (float)jarg2;
76011   {
76012     try {
76013       (arg1)->SetFlickSpeedCoefficient(arg2);
76014     } catch (std::out_of_range& e) {
76015       {
76016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76017       };
76018     } catch (std::exception& e) {
76019       {
76020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76021       };
76022     } catch (Dali::DaliException e) {
76023       {
76024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76025       };
76026     } catch (...) {
76027       {
76028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76029       };
76030     }
76031   }
76032
76033 }
76034
76035
76036 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
76037   void * jresult ;
76038   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76039   Dali::Vector2 result;
76040
76041   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76042   {
76043     try {
76044       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
76045     } catch (std::out_of_range& e) {
76046       {
76047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76048       };
76049     } catch (std::exception& e) {
76050       {
76051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76052       };
76053     } catch (Dali::DaliException e) {
76054       {
76055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76056       };
76057     } catch (...) {
76058       {
76059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76060       };
76061     }
76062   }
76063
76064   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76065   return jresult;
76066 }
76067
76068
76069 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
76070   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76071   Dali::Vector2 *arg2 = 0 ;
76072
76073   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76074   arg2 = (Dali::Vector2 *)jarg2;
76075   if (!arg2) {
76076     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76077     return ;
76078   }
76079   {
76080     try {
76081       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
76082     } catch (std::out_of_range& e) {
76083       {
76084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76085       };
76086     } catch (std::exception& e) {
76087       {
76088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76089       };
76090     } catch (Dali::DaliException e) {
76091       {
76092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76093       };
76094     } catch (...) {
76095       {
76096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76097       };
76098     }
76099   }
76100
76101 }
76102
76103
76104 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
76105   float jresult ;
76106   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76107   float result;
76108
76109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76110   {
76111     try {
76112       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
76113     } catch (std::out_of_range& e) {
76114       {
76115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76116       };
76117     } catch (std::exception& e) {
76118       {
76119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76120       };
76121     } catch (Dali::DaliException e) {
76122       {
76123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76124       };
76125     } catch (...) {
76126       {
76127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76128       };
76129     }
76130   }
76131
76132   jresult = result;
76133   return jresult;
76134 }
76135
76136
76137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
76138   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76139   float arg2 ;
76140
76141   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76142   arg2 = (float)jarg2;
76143   {
76144     try {
76145       (arg1)->SetMinimumSpeedForFlick(arg2);
76146     } catch (std::out_of_range& e) {
76147       {
76148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76149       };
76150     } catch (std::exception& e) {
76151       {
76152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76153       };
76154     } catch (Dali::DaliException e) {
76155       {
76156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76157       };
76158     } catch (...) {
76159       {
76160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76161       };
76162     }
76163   }
76164
76165 }
76166
76167
76168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
76169   float jresult ;
76170   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76171   float result;
76172
76173   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76174   {
76175     try {
76176       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
76177     } catch (std::out_of_range& e) {
76178       {
76179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76180       };
76181     } catch (std::exception& e) {
76182       {
76183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76184       };
76185     } catch (Dali::DaliException e) {
76186       {
76187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76188       };
76189     } catch (...) {
76190       {
76191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76192       };
76193     }
76194   }
76195
76196   jresult = result;
76197   return jresult;
76198 }
76199
76200
76201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
76202   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76203   float arg2 ;
76204
76205   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76206   arg2 = (float)jarg2;
76207   {
76208     try {
76209       (arg1)->SetMaxFlickSpeed(arg2);
76210     } catch (std::out_of_range& e) {
76211       {
76212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76213       };
76214     } catch (std::exception& e) {
76215       {
76216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76217       };
76218     } catch (Dali::DaliException e) {
76219       {
76220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76221       };
76222     } catch (...) {
76223       {
76224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76225       };
76226     }
76227   }
76228
76229 }
76230
76231
76232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
76233   void * jresult ;
76234   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76235   Dali::Vector2 result;
76236
76237   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76238   {
76239     try {
76240       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
76241     } catch (std::out_of_range& e) {
76242       {
76243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76244       };
76245     } catch (std::exception& e) {
76246       {
76247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76248       };
76249     } catch (Dali::DaliException e) {
76250       {
76251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76252       };
76253     } catch (...) {
76254       {
76255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76256       };
76257     }
76258   }
76259
76260   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76261   return jresult;
76262 }
76263
76264
76265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
76266   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76267   Dali::Vector2 arg2 ;
76268   Dali::Vector2 *argp2 ;
76269
76270   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76271   argp2 = (Dali::Vector2 *)jarg2;
76272   if (!argp2) {
76273     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
76274     return ;
76275   }
76276   arg2 = *argp2;
76277   {
76278     try {
76279       (arg1)->SetWheelScrollDistanceStep(arg2);
76280     } catch (std::out_of_range& e) {
76281       {
76282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76283       };
76284     } catch (std::exception& e) {
76285       {
76286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76287       };
76288     } catch (Dali::DaliException e) {
76289       {
76290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76291       };
76292     } catch (...) {
76293       {
76294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76295       };
76296     }
76297   }
76298
76299 }
76300
76301
76302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
76303   void * jresult ;
76304   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76305   Dali::Vector2 result;
76306
76307   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76308   {
76309     try {
76310       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
76311     } catch (std::out_of_range& e) {
76312       {
76313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76314       };
76315     } catch (std::exception& e) {
76316       {
76317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76318       };
76319     } catch (Dali::DaliException e) {
76320       {
76321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76322       };
76323     } catch (...) {
76324       {
76325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76326       };
76327     }
76328   }
76329
76330   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
76331   return jresult;
76332 }
76333
76334
76335 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
76336   unsigned int jresult ;
76337   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76338   unsigned int result;
76339
76340   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76341   {
76342     try {
76343       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
76344     } catch (std::out_of_range& e) {
76345       {
76346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76347       };
76348     } catch (std::exception& e) {
76349       {
76350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76351       };
76352     } catch (Dali::DaliException e) {
76353       {
76354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76355       };
76356     } catch (...) {
76357       {
76358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76359       };
76360     }
76361   }
76362
76363   jresult = result;
76364   return jresult;
76365 }
76366
76367
76368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
76369   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76370   Dali::Vector2 *arg2 = 0 ;
76371
76372   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76373   arg2 = (Dali::Vector2 *)jarg2;
76374   if (!arg2) {
76375     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76376     return ;
76377   }
76378   {
76379     try {
76380       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
76381     } catch (std::out_of_range& e) {
76382       {
76383         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76384       };
76385     } catch (std::exception& e) {
76386       {
76387         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76388       };
76389     } catch (Dali::DaliException e) {
76390       {
76391         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76392       };
76393     } catch (...) {
76394       {
76395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76396       };
76397     }
76398   }
76399
76400 }
76401
76402
76403 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
76404   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76405   Dali::Vector2 *arg2 = 0 ;
76406   float arg3 ;
76407
76408   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76409   arg2 = (Dali::Vector2 *)jarg2;
76410   if (!arg2) {
76411     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76412     return ;
76413   }
76414   arg3 = (float)jarg3;
76415   {
76416     try {
76417       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
76418     } catch (std::out_of_range& e) {
76419       {
76420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76421       };
76422     } catch (std::exception& e) {
76423       {
76424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76425       };
76426     } catch (Dali::DaliException e) {
76427       {
76428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76429       };
76430     } catch (...) {
76431       {
76432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76433       };
76434     }
76435   }
76436
76437 }
76438
76439
76440 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
76441   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76442   Dali::Vector2 *arg2 = 0 ;
76443   float arg3 ;
76444   Dali::AlphaFunction arg4 ;
76445   Dali::AlphaFunction *argp4 ;
76446
76447   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76448   arg2 = (Dali::Vector2 *)jarg2;
76449   if (!arg2) {
76450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76451     return ;
76452   }
76453   arg3 = (float)jarg3;
76454   argp4 = (Dali::AlphaFunction *)jarg4;
76455   if (!argp4) {
76456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76457     return ;
76458   }
76459   arg4 = *argp4;
76460   {
76461     try {
76462       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
76463     } catch (std::out_of_range& e) {
76464       {
76465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76466       };
76467     } catch (std::exception& e) {
76468       {
76469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76470       };
76471     } catch (Dali::DaliException e) {
76472       {
76473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76474       };
76475     } catch (...) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76478       };
76479     }
76480   }
76481
76482 }
76483
76484
76485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
76486   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76487   Dali::Vector2 *arg2 = 0 ;
76488   float arg3 ;
76489   Dali::Toolkit::DirectionBias arg4 ;
76490   Dali::Toolkit::DirectionBias arg5 ;
76491
76492   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76493   arg2 = (Dali::Vector2 *)jarg2;
76494   if (!arg2) {
76495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76496     return ;
76497   }
76498   arg3 = (float)jarg3;
76499   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76500   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76501   {
76502     try {
76503       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76504     } catch (std::out_of_range& e) {
76505       {
76506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76507       };
76508     } catch (std::exception& e) {
76509       {
76510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76511       };
76512     } catch (Dali::DaliException e) {
76513       {
76514         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76515       };
76516     } catch (...) {
76517       {
76518         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76519       };
76520     }
76521   }
76522
76523 }
76524
76525
76526 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76528   Dali::Vector2 *arg2 = 0 ;
76529   float arg3 ;
76530   Dali::AlphaFunction arg4 ;
76531   Dali::Toolkit::DirectionBias arg5 ;
76532   Dali::Toolkit::DirectionBias arg6 ;
76533   Dali::AlphaFunction *argp4 ;
76534
76535   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76536   arg2 = (Dali::Vector2 *)jarg2;
76537   if (!arg2) {
76538     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76539     return ;
76540   }
76541   arg3 = (float)jarg3;
76542   argp4 = (Dali::AlphaFunction *)jarg4;
76543   if (!argp4) {
76544     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76545     return ;
76546   }
76547   arg4 = *argp4;
76548   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76549   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76550   {
76551     try {
76552       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76553     } catch (std::out_of_range& e) {
76554       {
76555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76556       };
76557     } catch (std::exception& e) {
76558       {
76559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76560       };
76561     } catch (Dali::DaliException e) {
76562       {
76563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76564       };
76565     } catch (...) {
76566       {
76567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76568       };
76569     }
76570   }
76571
76572 }
76573
76574
76575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76576   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76577   unsigned int arg2 ;
76578
76579   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76580   arg2 = (unsigned int)jarg2;
76581   {
76582     try {
76583       (arg1)->ScrollTo(arg2);
76584     } catch (std::out_of_range& e) {
76585       {
76586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76587       };
76588     } catch (std::exception& e) {
76589       {
76590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76591       };
76592     } catch (Dali::DaliException e) {
76593       {
76594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76595       };
76596     } catch (...) {
76597       {
76598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76599       };
76600     }
76601   }
76602
76603 }
76604
76605
76606 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76607   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76608   unsigned int arg2 ;
76609   float arg3 ;
76610
76611   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76612   arg2 = (unsigned int)jarg2;
76613   arg3 = (float)jarg3;
76614   {
76615     try {
76616       (arg1)->ScrollTo(arg2,arg3);
76617     } catch (std::out_of_range& e) {
76618       {
76619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76620       };
76621     } catch (std::exception& e) {
76622       {
76623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76624       };
76625     } catch (Dali::DaliException e) {
76626       {
76627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76628       };
76629     } catch (...) {
76630       {
76631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76632       };
76633     }
76634   }
76635
76636 }
76637
76638
76639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76640   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76641   unsigned int arg2 ;
76642   float arg3 ;
76643   Dali::Toolkit::DirectionBias arg4 ;
76644
76645   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76646   arg2 = (unsigned int)jarg2;
76647   arg3 = (float)jarg3;
76648   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76649   {
76650     try {
76651       (arg1)->ScrollTo(arg2,arg3,arg4);
76652     } catch (std::out_of_range& e) {
76653       {
76654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76655       };
76656     } catch (std::exception& e) {
76657       {
76658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76659       };
76660     } catch (Dali::DaliException e) {
76661       {
76662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76663       };
76664     } catch (...) {
76665       {
76666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76667       };
76668     }
76669   }
76670
76671 }
76672
76673
76674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76675   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76676   Dali::Actor *arg2 = 0 ;
76677
76678   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76679   arg2 = (Dali::Actor *)jarg2;
76680   if (!arg2) {
76681     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76682     return ;
76683   }
76684   {
76685     try {
76686       (arg1)->ScrollTo(*arg2);
76687     } catch (std::out_of_range& e) {
76688       {
76689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76690       };
76691     } catch (std::exception& e) {
76692       {
76693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76694       };
76695     } catch (Dali::DaliException e) {
76696       {
76697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76698       };
76699     } catch (...) {
76700       {
76701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76702       };
76703     }
76704   }
76705
76706 }
76707
76708
76709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76710   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76711   Dali::Actor *arg2 = 0 ;
76712   float arg3 ;
76713
76714   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76715   arg2 = (Dali::Actor *)jarg2;
76716   if (!arg2) {
76717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76718     return ;
76719   }
76720   arg3 = (float)jarg3;
76721   {
76722     try {
76723       (arg1)->ScrollTo(*arg2,arg3);
76724     } catch (std::out_of_range& e) {
76725       {
76726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76727       };
76728     } catch (std::exception& e) {
76729       {
76730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76731       };
76732     } catch (Dali::DaliException e) {
76733       {
76734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76735       };
76736     } catch (...) {
76737       {
76738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76739       };
76740     }
76741   }
76742
76743 }
76744
76745
76746 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76747   unsigned int jresult ;
76748   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76749   bool result;
76750
76751   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76752   {
76753     try {
76754       result = (bool)(arg1)->ScrollToSnapPoint();
76755     } catch (std::out_of_range& e) {
76756       {
76757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76758       };
76759     } catch (std::exception& e) {
76760       {
76761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76762       };
76763     } catch (Dali::DaliException e) {
76764       {
76765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76766       };
76767     } catch (...) {
76768       {
76769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76770       };
76771     }
76772   }
76773
76774   jresult = result;
76775   return jresult;
76776 }
76777
76778
76779 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76780   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76781   Dali::Constraint arg2 ;
76782   Dali::Constraint *argp2 ;
76783
76784   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76785   argp2 = (Dali::Constraint *)jarg2;
76786   if (!argp2) {
76787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76788     return ;
76789   }
76790   arg2 = *argp2;
76791   {
76792     try {
76793       (arg1)->ApplyConstraintToChildren(arg2);
76794     } catch (std::out_of_range& e) {
76795       {
76796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76797       };
76798     } catch (std::exception& e) {
76799       {
76800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76801       };
76802     } catch (Dali::DaliException e) {
76803       {
76804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76805       };
76806     } catch (...) {
76807       {
76808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76809       };
76810     }
76811   }
76812
76813 }
76814
76815
76816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76817   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76818
76819   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76820   {
76821     try {
76822       (arg1)->RemoveConstraintsFromChildren();
76823     } catch (std::out_of_range& e) {
76824       {
76825         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76826       };
76827     } catch (std::exception& e) {
76828       {
76829         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76830       };
76831     } catch (Dali::DaliException e) {
76832       {
76833         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76834       };
76835     } catch (...) {
76836       {
76837         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76838       };
76839     }
76840   }
76841
76842 }
76843
76844
76845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76846   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76847   Dali::Toolkit::ScrollViewEffect arg2 ;
76848   Dali::Toolkit::ScrollViewEffect *argp2 ;
76849
76850   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76851   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76852   if (!argp2) {
76853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76854     return ;
76855   }
76856   arg2 = *argp2;
76857   {
76858     try {
76859       (arg1)->ApplyEffect(arg2);
76860     } catch (std::out_of_range& e) {
76861       {
76862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76863       };
76864     } catch (std::exception& e) {
76865       {
76866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76867       };
76868     } catch (Dali::DaliException e) {
76869       {
76870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76871       };
76872     } catch (...) {
76873       {
76874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76875       };
76876     }
76877   }
76878
76879 }
76880
76881
76882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76883   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76884   Dali::Toolkit::ScrollViewEffect arg2 ;
76885   Dali::Toolkit::ScrollViewEffect *argp2 ;
76886
76887   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76888   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76889   if (!argp2) {
76890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76891     return ;
76892   }
76893   arg2 = *argp2;
76894   {
76895     try {
76896       (arg1)->RemoveEffect(arg2);
76897     } catch (std::out_of_range& e) {
76898       {
76899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76900       };
76901     } catch (std::exception& e) {
76902       {
76903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76904       };
76905     } catch (Dali::DaliException e) {
76906       {
76907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76908       };
76909     } catch (...) {
76910       {
76911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76912       };
76913     }
76914   }
76915
76916 }
76917
76918
76919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76920   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76921
76922   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76923   {
76924     try {
76925       (arg1)->RemoveAllEffects();
76926     } catch (std::out_of_range& e) {
76927       {
76928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76929       };
76930     } catch (std::exception& e) {
76931       {
76932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76933       };
76934     } catch (Dali::DaliException e) {
76935       {
76936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76937       };
76938     } catch (...) {
76939       {
76940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76941       };
76942     }
76943   }
76944
76945 }
76946
76947
76948 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76949   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76950   Dali::Actor arg2 ;
76951   Dali::Actor *argp2 ;
76952
76953   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76954   argp2 = (Dali::Actor *)jarg2;
76955   if (!argp2) {
76956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76957     return ;
76958   }
76959   arg2 = *argp2;
76960   {
76961     try {
76962       (arg1)->BindActor(arg2);
76963     } catch (std::out_of_range& e) {
76964       {
76965         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76966       };
76967     } catch (std::exception& e) {
76968       {
76969         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76970       };
76971     } catch (Dali::DaliException e) {
76972       {
76973         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76974       };
76975     } catch (...) {
76976       {
76977         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76978       };
76979     }
76980   }
76981
76982 }
76983
76984
76985 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76986   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76987   Dali::Actor arg2 ;
76988   Dali::Actor *argp2 ;
76989
76990   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76991   argp2 = (Dali::Actor *)jarg2;
76992   if (!argp2) {
76993     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76994     return ;
76995   }
76996   arg2 = *argp2;
76997   {
76998     try {
76999       (arg1)->UnbindActor(arg2);
77000     } catch (std::out_of_range& e) {
77001       {
77002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77003       };
77004     } catch (std::exception& e) {
77005       {
77006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77007       };
77008     } catch (Dali::DaliException e) {
77009       {
77010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77011       };
77012     } catch (...) {
77013       {
77014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77015       };
77016     }
77017   }
77018
77019 }
77020
77021
77022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
77023   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77024   Dali::Radian arg2 ;
77025   Dali::Radian arg3 ;
77026   Dali::Radian *argp2 ;
77027   Dali::Radian *argp3 ;
77028
77029   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77030   argp2 = (Dali::Radian *)jarg2;
77031   if (!argp2) {
77032     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77033     return ;
77034   }
77035   arg2 = *argp2;
77036   argp3 = (Dali::Radian *)jarg3;
77037   if (!argp3) {
77038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77039     return ;
77040   }
77041   arg3 = *argp3;
77042   {
77043     try {
77044       (arg1)->SetScrollingDirection(arg2,arg3);
77045     } catch (std::out_of_range& e) {
77046       {
77047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77048       };
77049     } catch (std::exception& e) {
77050       {
77051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77052       };
77053     } catch (Dali::DaliException e) {
77054       {
77055         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77056       };
77057     } catch (...) {
77058       {
77059         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77060       };
77061     }
77062   }
77063
77064 }
77065
77066
77067 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
77068   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77069   Dali::Radian arg2 ;
77070   Dali::Radian *argp2 ;
77071
77072   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77073   argp2 = (Dali::Radian *)jarg2;
77074   if (!argp2) {
77075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77076     return ;
77077   }
77078   arg2 = *argp2;
77079   {
77080     try {
77081       (arg1)->SetScrollingDirection(arg2);
77082     } catch (std::out_of_range& e) {
77083       {
77084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77085       };
77086     } catch (std::exception& e) {
77087       {
77088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77089       };
77090     } catch (Dali::DaliException e) {
77091       {
77092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77093       };
77094     } catch (...) {
77095       {
77096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77097       };
77098     }
77099   }
77100
77101 }
77102
77103
77104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
77105   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77106   Dali::Radian arg2 ;
77107   Dali::Radian *argp2 ;
77108
77109   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77110   argp2 = (Dali::Radian *)jarg2;
77111   if (!argp2) {
77112     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
77113     return ;
77114   }
77115   arg2 = *argp2;
77116   {
77117     try {
77118       (arg1)->RemoveScrollingDirection(arg2);
77119     } catch (std::out_of_range& e) {
77120       {
77121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77122       };
77123     } catch (std::exception& e) {
77124       {
77125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77126       };
77127     } catch (Dali::DaliException e) {
77128       {
77129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77130       };
77131     } catch (...) {
77132       {
77133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77134       };
77135     }
77136   }
77137
77138 }
77139
77140
77141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
77142   void * jresult ;
77143   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
77144   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
77145
77146   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
77147   {
77148     try {
77149       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
77150     } catch (std::out_of_range& e) {
77151       {
77152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77153       };
77154     } catch (std::exception& e) {
77155       {
77156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77157       };
77158     } catch (Dali::DaliException e) {
77159       {
77160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77161       };
77162     } catch (...) {
77163       {
77164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77165       };
77166     }
77167   }
77168
77169   jresult = (void *)result;
77170   return jresult;
77171 }
77172
77173
77174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
77175   int jresult ;
77176   int result;
77177
77178   result = (int)Dali::Toolkit::TableView::Property::ROWS;
77179   jresult = (int)result;
77180   return jresult;
77181 }
77182
77183
77184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
77185   int jresult ;
77186   int result;
77187
77188   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
77189   jresult = (int)result;
77190   return jresult;
77191 }
77192
77193
77194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
77195   int jresult ;
77196   int result;
77197
77198   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
77199   jresult = (int)result;
77200   return jresult;
77201 }
77202
77203
77204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
77205   int jresult ;
77206   int result;
77207
77208   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
77209   jresult = (int)result;
77210   return jresult;
77211 }
77212
77213
77214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
77215   int jresult ;
77216   int result;
77217
77218   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
77219   jresult = (int)result;
77220   return jresult;
77221 }
77222
77223
77224 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
77225   void * jresult ;
77226   Dali::Toolkit::TableView::Property *result = 0 ;
77227
77228   {
77229     try {
77230       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
77231     } catch (std::out_of_range& e) {
77232       {
77233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77234       };
77235     } catch (std::exception& e) {
77236       {
77237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77238       };
77239     } catch (Dali::DaliException e) {
77240       {
77241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77242       };
77243     } catch (...) {
77244       {
77245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77246       };
77247     }
77248   }
77249
77250   jresult = (void *)result;
77251   return jresult;
77252 }
77253
77254
77255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
77256   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
77257
77258   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
77259   {
77260     try {
77261       delete arg1;
77262     } catch (std::out_of_range& e) {
77263       {
77264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77265       };
77266     } catch (std::exception& e) {
77267       {
77268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77269       };
77270     } catch (Dali::DaliException e) {
77271       {
77272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77273       };
77274     } catch (...) {
77275       {
77276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77277       };
77278     }
77279   }
77280
77281 }
77282
77283
77284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
77285   int jresult ;
77286   int result;
77287
77288   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
77289   jresult = (int)result;
77290   return jresult;
77291 }
77292
77293
77294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
77295   int jresult ;
77296   int result;
77297
77298   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
77299   jresult = (int)result;
77300   return jresult;
77301 }
77302
77303
77304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
77305   int jresult ;
77306   int result;
77307
77308   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
77309   jresult = (int)result;
77310   return jresult;
77311 }
77312
77313
77314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
77315   int jresult ;
77316   int result;
77317
77318   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
77319   jresult = (int)result;
77320   return jresult;
77321 }
77322
77323
77324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
77325   int jresult ;
77326   int result;
77327
77328   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
77329   jresult = (int)result;
77330   return jresult;
77331 }
77332
77333
77334 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
77335   void * jresult ;
77336   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
77337
77338   {
77339     try {
77340       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
77341     } catch (std::out_of_range& e) {
77342       {
77343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77344       };
77345     } catch (std::exception& e) {
77346       {
77347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77348       };
77349     } catch (Dali::DaliException e) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77352       };
77353     } catch (...) {
77354       {
77355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77356       };
77357     }
77358   }
77359
77360   jresult = (void *)result;
77361   return jresult;
77362 }
77363
77364
77365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
77366   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
77367
77368   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
77369   {
77370     try {
77371       delete arg1;
77372     } catch (std::out_of_range& e) {
77373       {
77374         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77375       };
77376     } catch (std::exception& e) {
77377       {
77378         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77379       };
77380     } catch (Dali::DaliException e) {
77381       {
77382         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77383       };
77384     } catch (...) {
77385       {
77386         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77387       };
77388     }
77389   }
77390
77391 }
77392
77393
77394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
77395   void * jresult ;
77396   unsigned int arg1 ;
77397   unsigned int arg2 ;
77398   unsigned int arg3 ;
77399   unsigned int arg4 ;
77400   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77401
77402   arg1 = (unsigned int)jarg1;
77403   arg2 = (unsigned int)jarg2;
77404   arg3 = (unsigned int)jarg3;
77405   arg4 = (unsigned int)jarg4;
77406   {
77407     try {
77408       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
77409     } catch (std::out_of_range& e) {
77410       {
77411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77412       };
77413     } catch (std::exception& e) {
77414       {
77415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77416       };
77417     } catch (Dali::DaliException e) {
77418       {
77419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77420       };
77421     } catch (...) {
77422       {
77423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77424       };
77425     }
77426   }
77427
77428   jresult = (void *)result;
77429   return jresult;
77430 }
77431
77432
77433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
77434   void * jresult ;
77435   unsigned int arg1 ;
77436   unsigned int arg2 ;
77437   unsigned int arg3 ;
77438   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77439
77440   arg1 = (unsigned int)jarg1;
77441   arg2 = (unsigned int)jarg2;
77442   arg3 = (unsigned int)jarg3;
77443   {
77444     try {
77445       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
77446     } catch (std::out_of_range& e) {
77447       {
77448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77449       };
77450     } catch (std::exception& e) {
77451       {
77452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77453       };
77454     } catch (Dali::DaliException e) {
77455       {
77456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77457       };
77458     } catch (...) {
77459       {
77460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77461       };
77462     }
77463   }
77464
77465   jresult = (void *)result;
77466   return jresult;
77467 }
77468
77469
77470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
77471   void * jresult ;
77472   unsigned int arg1 ;
77473   unsigned int arg2 ;
77474   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77475
77476   arg1 = (unsigned int)jarg1;
77477   arg2 = (unsigned int)jarg2;
77478   {
77479     try {
77480       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
77481     } catch (std::out_of_range& e) {
77482       {
77483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77484       };
77485     } catch (std::exception& e) {
77486       {
77487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77488       };
77489     } catch (Dali::DaliException e) {
77490       {
77491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77492       };
77493     } catch (...) {
77494       {
77495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77496       };
77497     }
77498   }
77499
77500   jresult = (void *)result;
77501   return jresult;
77502 }
77503
77504
77505 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77506   void * jresult ;
77507   unsigned int arg1 ;
77508   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77509
77510   arg1 = (unsigned int)jarg1;
77511   {
77512     try {
77513       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77514     } catch (std::out_of_range& e) {
77515       {
77516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77517       };
77518     } catch (std::exception& e) {
77519       {
77520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77521       };
77522     } catch (Dali::DaliException e) {
77523       {
77524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77525       };
77526     } catch (...) {
77527       {
77528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77529       };
77530     }
77531   }
77532
77533   jresult = (void *)result;
77534   return jresult;
77535 }
77536
77537
77538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77539   void * jresult ;
77540   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77541
77542   {
77543     try {
77544       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77545     } catch (std::out_of_range& e) {
77546       {
77547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77548       };
77549     } catch (std::exception& e) {
77550       {
77551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77552       };
77553     } catch (Dali::DaliException e) {
77554       {
77555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77556       };
77557     } catch (...) {
77558       {
77559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77560       };
77561     }
77562   }
77563
77564   jresult = (void *)result;
77565   return jresult;
77566 }
77567
77568
77569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77570   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77571   unsigned int arg2 ;
77572
77573   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77574   arg2 = (unsigned int)jarg2;
77575   if (arg1) (arg1)->rowIndex = arg2;
77576 }
77577
77578
77579 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77580   unsigned int jresult ;
77581   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77582   unsigned int result;
77583
77584   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77585   result = (unsigned int) ((arg1)->rowIndex);
77586   jresult = result;
77587   return jresult;
77588 }
77589
77590
77591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77592   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77593   unsigned int arg2 ;
77594
77595   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77596   arg2 = (unsigned int)jarg2;
77597   if (arg1) (arg1)->columnIndex = arg2;
77598 }
77599
77600
77601 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77602   unsigned int jresult ;
77603   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77604   unsigned int result;
77605
77606   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77607   result = (unsigned int) ((arg1)->columnIndex);
77608   jresult = result;
77609   return jresult;
77610 }
77611
77612
77613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77614   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77615   unsigned int arg2 ;
77616
77617   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77618   arg2 = (unsigned int)jarg2;
77619   if (arg1) (arg1)->rowSpan = arg2;
77620 }
77621
77622
77623 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77624   unsigned int jresult ;
77625   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77626   unsigned int result;
77627
77628   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77629   result = (unsigned int) ((arg1)->rowSpan);
77630   jresult = result;
77631   return jresult;
77632 }
77633
77634
77635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77636   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77637   unsigned int arg2 ;
77638
77639   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77640   arg2 = (unsigned int)jarg2;
77641   if (arg1) (arg1)->columnSpan = arg2;
77642 }
77643
77644
77645 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77646   unsigned int jresult ;
77647   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77648   unsigned int result;
77649
77650   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77651   result = (unsigned int) ((arg1)->columnSpan);
77652   jresult = result;
77653   return jresult;
77654 }
77655
77656
77657 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77658   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77659
77660   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77661   {
77662     try {
77663       delete arg1;
77664     } catch (std::out_of_range& e) {
77665       {
77666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77667       };
77668     } catch (std::exception& e) {
77669       {
77670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77671       };
77672     } catch (Dali::DaliException e) {
77673       {
77674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77675       };
77676     } catch (...) {
77677       {
77678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77679       };
77680     }
77681   }
77682
77683 }
77684
77685
77686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77687   void * jresult ;
77688   Dali::Toolkit::TableView *result = 0 ;
77689
77690   {
77691     try {
77692       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77693     } catch (std::out_of_range& e) {
77694       {
77695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77696       };
77697     } catch (std::exception& e) {
77698       {
77699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77700       };
77701     } catch (Dali::DaliException e) {
77702       {
77703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77704       };
77705     } catch (...) {
77706       {
77707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77708       };
77709     }
77710   }
77711
77712   jresult = (void *)result;
77713   return jresult;
77714 }
77715
77716
77717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77718   void * jresult ;
77719   Dali::Toolkit::TableView *arg1 = 0 ;
77720   Dali::Toolkit::TableView *result = 0 ;
77721
77722   arg1 = (Dali::Toolkit::TableView *)jarg1;
77723   if (!arg1) {
77724     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77725     return 0;
77726   }
77727   {
77728     try {
77729       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77730     } catch (std::out_of_range& e) {
77731       {
77732         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77733       };
77734     } catch (std::exception& e) {
77735       {
77736         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77737       };
77738     } catch (Dali::DaliException e) {
77739       {
77740         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77741       };
77742     } catch (...) {
77743       {
77744         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77745       };
77746     }
77747   }
77748
77749   jresult = (void *)result;
77750   return jresult;
77751 }
77752
77753
77754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77755   void * jresult ;
77756   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77757   Dali::Toolkit::TableView *arg2 = 0 ;
77758   Dali::Toolkit::TableView *result = 0 ;
77759
77760   arg1 = (Dali::Toolkit::TableView *)jarg1;
77761   arg2 = (Dali::Toolkit::TableView *)jarg2;
77762   if (!arg2) {
77763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77764     return 0;
77765   }
77766   {
77767     try {
77768       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77769     } catch (std::out_of_range& e) {
77770       {
77771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77772       };
77773     } catch (std::exception& e) {
77774       {
77775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77776       };
77777     } catch (Dali::DaliException e) {
77778       {
77779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77780       };
77781     } catch (...) {
77782       {
77783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77784       };
77785     }
77786   }
77787
77788   jresult = (void *)result;
77789   return jresult;
77790 }
77791
77792
77793 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77794   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77795
77796   arg1 = (Dali::Toolkit::TableView *)jarg1;
77797   {
77798     try {
77799       delete arg1;
77800     } catch (std::out_of_range& e) {
77801       {
77802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77803       };
77804     } catch (std::exception& e) {
77805       {
77806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77807       };
77808     } catch (Dali::DaliException e) {
77809       {
77810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77811       };
77812     } catch (...) {
77813       {
77814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77815       };
77816     }
77817   }
77818
77819 }
77820
77821
77822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77823   void * jresult ;
77824   unsigned int arg1 ;
77825   unsigned int arg2 ;
77826   Dali::Toolkit::TableView result;
77827
77828   arg1 = (unsigned int)jarg1;
77829   arg2 = (unsigned int)jarg2;
77830   {
77831     try {
77832       result = Dali::Toolkit::TableView::New(arg1,arg2);
77833     } catch (std::out_of_range& e) {
77834       {
77835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77836       };
77837     } catch (std::exception& e) {
77838       {
77839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77840       };
77841     } catch (Dali::DaliException e) {
77842       {
77843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77844       };
77845     } catch (...) {
77846       {
77847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77848       };
77849     }
77850   }
77851
77852   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77853   return jresult;
77854 }
77855
77856
77857 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77858   void * jresult ;
77859   Dali::BaseHandle arg1 ;
77860   Dali::BaseHandle *argp1 ;
77861   Dali::Toolkit::TableView result;
77862
77863   argp1 = (Dali::BaseHandle *)jarg1;
77864   if (!argp1) {
77865     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77866     return 0;
77867   }
77868   arg1 = *argp1;
77869   {
77870     try {
77871       result = Dali::Toolkit::TableView::DownCast(arg1);
77872     } catch (std::out_of_range& e) {
77873       {
77874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77875       };
77876     } catch (std::exception& e) {
77877       {
77878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77879       };
77880     } catch (Dali::DaliException e) {
77881       {
77882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77883       };
77884     } catch (...) {
77885       {
77886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77887       };
77888     }
77889   }
77890
77891   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77892   return jresult;
77893 }
77894
77895
77896 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77897   unsigned int jresult ;
77898   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77899   Dali::Actor arg2 ;
77900   Dali::Toolkit::TableView::CellPosition arg3 ;
77901   Dali::Actor *argp2 ;
77902   Dali::Toolkit::TableView::CellPosition *argp3 ;
77903   bool result;
77904
77905   arg1 = (Dali::Toolkit::TableView *)jarg1;
77906   argp2 = (Dali::Actor *)jarg2;
77907   if (!argp2) {
77908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77909     return 0;
77910   }
77911   arg2 = *argp2;
77912   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77913   if (!argp3) {
77914     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77915     return 0;
77916   }
77917   arg3 = *argp3;
77918   {
77919     try {
77920       result = (bool)(arg1)->AddChild(arg2,arg3);
77921     } catch (std::out_of_range& e) {
77922       {
77923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77924       };
77925     } catch (std::exception& e) {
77926       {
77927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77928       };
77929     } catch (Dali::DaliException e) {
77930       {
77931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77932       };
77933     } catch (...) {
77934       {
77935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77936       };
77937     }
77938   }
77939
77940   jresult = result;
77941   return jresult;
77942 }
77943
77944
77945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77946   void * jresult ;
77947   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77948   Dali::Toolkit::TableView::CellPosition arg2 ;
77949   Dali::Toolkit::TableView::CellPosition *argp2 ;
77950   Dali::Actor result;
77951
77952   arg1 = (Dali::Toolkit::TableView *)jarg1;
77953   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77954   if (!argp2) {
77955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77956     return 0;
77957   }
77958   arg2 = *argp2;
77959   {
77960     try {
77961       result = (arg1)->GetChildAt(arg2);
77962     } catch (std::out_of_range& e) {
77963       {
77964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77965       };
77966     } catch (std::exception& e) {
77967       {
77968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77969       };
77970     } catch (Dali::DaliException e) {
77971       {
77972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77973       };
77974     } catch (...) {
77975       {
77976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77977       };
77978     }
77979   }
77980
77981   jresult = new Dali::Actor((const Dali::Actor &)result);
77982   return jresult;
77983 }
77984
77985
77986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77987   void * jresult ;
77988   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77989   Dali::Toolkit::TableView::CellPosition arg2 ;
77990   Dali::Toolkit::TableView::CellPosition *argp2 ;
77991   Dali::Actor result;
77992
77993   arg1 = (Dali::Toolkit::TableView *)jarg1;
77994   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77995   if (!argp2) {
77996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77997     return 0;
77998   }
77999   arg2 = *argp2;
78000   {
78001     try {
78002       result = (arg1)->RemoveChildAt(arg2);
78003     } catch (std::out_of_range& e) {
78004       {
78005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78006       };
78007     } catch (std::exception& e) {
78008       {
78009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78010       };
78011     } catch (Dali::DaliException e) {
78012       {
78013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78014       };
78015     } catch (...) {
78016       {
78017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78018       };
78019     }
78020   }
78021
78022   jresult = new Dali::Actor((const Dali::Actor &)result);
78023   return jresult;
78024 }
78025
78026
78027 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
78028   unsigned int jresult ;
78029   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78030   Dali::Actor arg2 ;
78031   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
78032   Dali::Actor *argp2 ;
78033   bool result;
78034
78035   arg1 = (Dali::Toolkit::TableView *)jarg1;
78036   argp2 = (Dali::Actor *)jarg2;
78037   if (!argp2) {
78038     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
78039     return 0;
78040   }
78041   arg2 = *argp2;
78042   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
78043   if (!arg3) {
78044     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
78045     return 0;
78046   }
78047   {
78048     try {
78049       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
78050     } catch (std::out_of_range& e) {
78051       {
78052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78053       };
78054     } catch (std::exception& e) {
78055       {
78056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78057       };
78058     } catch (Dali::DaliException e) {
78059       {
78060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78061       };
78062     } catch (...) {
78063       {
78064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78065       };
78066     }
78067   }
78068
78069   jresult = result;
78070   return jresult;
78071 }
78072
78073
78074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
78075   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78076   unsigned int arg2 ;
78077
78078   arg1 = (Dali::Toolkit::TableView *)jarg1;
78079   arg2 = (unsigned int)jarg2;
78080   {
78081     try {
78082       (arg1)->InsertRow(arg2);
78083     } catch (std::out_of_range& e) {
78084       {
78085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78086       };
78087     } catch (std::exception& e) {
78088       {
78089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78090       };
78091     } catch (Dali::DaliException e) {
78092       {
78093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78094       };
78095     } catch (...) {
78096       {
78097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78098       };
78099     }
78100   }
78101
78102 }
78103
78104
78105 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
78106   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78107   unsigned int arg2 ;
78108
78109   arg1 = (Dali::Toolkit::TableView *)jarg1;
78110   arg2 = (unsigned int)jarg2;
78111   {
78112     try {
78113       (arg1)->DeleteRow(arg2);
78114     } catch (std::out_of_range& e) {
78115       {
78116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78117       };
78118     } catch (std::exception& e) {
78119       {
78120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78121       };
78122     } catch (Dali::DaliException e) {
78123       {
78124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78125       };
78126     } catch (...) {
78127       {
78128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78129       };
78130     }
78131   }
78132
78133 }
78134
78135
78136 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
78137   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78138   unsigned int arg2 ;
78139   std::vector< Dali::Actor > *arg3 = 0 ;
78140
78141   arg1 = (Dali::Toolkit::TableView *)jarg1;
78142   arg2 = (unsigned int)jarg2;
78143   arg3 = (std::vector< Dali::Actor > *)jarg3;
78144   if (!arg3) {
78145     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78146     return ;
78147   }
78148   {
78149     try {
78150       (arg1)->DeleteRow(arg2,*arg3);
78151     } catch (std::out_of_range& e) {
78152       {
78153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78154       };
78155     } catch (std::exception& e) {
78156       {
78157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78158       };
78159     } catch (Dali::DaliException e) {
78160       {
78161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78162       };
78163     } catch (...) {
78164       {
78165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78166       };
78167     }
78168   }
78169
78170 }
78171
78172
78173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
78174   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78175   unsigned int arg2 ;
78176
78177   arg1 = (Dali::Toolkit::TableView *)jarg1;
78178   arg2 = (unsigned int)jarg2;
78179   {
78180     try {
78181       (arg1)->InsertColumn(arg2);
78182     } catch (std::out_of_range& e) {
78183       {
78184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78185       };
78186     } catch (std::exception& e) {
78187       {
78188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78189       };
78190     } catch (Dali::DaliException e) {
78191       {
78192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78193       };
78194     } catch (...) {
78195       {
78196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78197       };
78198     }
78199   }
78200
78201 }
78202
78203
78204 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
78205   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78206   unsigned int arg2 ;
78207
78208   arg1 = (Dali::Toolkit::TableView *)jarg1;
78209   arg2 = (unsigned int)jarg2;
78210   {
78211     try {
78212       (arg1)->DeleteColumn(arg2);
78213     } catch (std::out_of_range& e) {
78214       {
78215         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78216       };
78217     } catch (std::exception& e) {
78218       {
78219         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78220       };
78221     } catch (Dali::DaliException e) {
78222       {
78223         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78224       };
78225     } catch (...) {
78226       {
78227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78228       };
78229     }
78230   }
78231
78232 }
78233
78234
78235 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
78236   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78237   unsigned int arg2 ;
78238   std::vector< Dali::Actor > *arg3 = 0 ;
78239
78240   arg1 = (Dali::Toolkit::TableView *)jarg1;
78241   arg2 = (unsigned int)jarg2;
78242   arg3 = (std::vector< Dali::Actor > *)jarg3;
78243   if (!arg3) {
78244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78245     return ;
78246   }
78247   {
78248     try {
78249       (arg1)->DeleteColumn(arg2,*arg3);
78250     } catch (std::out_of_range& e) {
78251       {
78252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78253       };
78254     } catch (std::exception& e) {
78255       {
78256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78257       };
78258     } catch (Dali::DaliException e) {
78259       {
78260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78261       };
78262     } catch (...) {
78263       {
78264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78265       };
78266     }
78267   }
78268
78269 }
78270
78271
78272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
78273   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78274   unsigned int arg2 ;
78275   unsigned int arg3 ;
78276
78277   arg1 = (Dali::Toolkit::TableView *)jarg1;
78278   arg2 = (unsigned int)jarg2;
78279   arg3 = (unsigned int)jarg3;
78280   {
78281     try {
78282       (arg1)->Resize(arg2,arg3);
78283     } catch (std::out_of_range& e) {
78284       {
78285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78286       };
78287     } catch (std::exception& e) {
78288       {
78289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78290       };
78291     } catch (Dali::DaliException e) {
78292       {
78293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78294       };
78295     } catch (...) {
78296       {
78297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78298       };
78299     }
78300   }
78301
78302 }
78303
78304
78305 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
78306   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78307   unsigned int arg2 ;
78308   unsigned int arg3 ;
78309   std::vector< Dali::Actor > *arg4 = 0 ;
78310
78311   arg1 = (Dali::Toolkit::TableView *)jarg1;
78312   arg2 = (unsigned int)jarg2;
78313   arg3 = (unsigned int)jarg3;
78314   arg4 = (std::vector< Dali::Actor > *)jarg4;
78315   if (!arg4) {
78316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
78317     return ;
78318   }
78319   {
78320     try {
78321       (arg1)->Resize(arg2,arg3,*arg4);
78322     } catch (std::out_of_range& e) {
78323       {
78324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78325       };
78326     } catch (std::exception& e) {
78327       {
78328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78329       };
78330     } catch (Dali::DaliException e) {
78331       {
78332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78333       };
78334     } catch (...) {
78335       {
78336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78337       };
78338     }
78339   }
78340
78341 }
78342
78343
78344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
78345   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78346   Dali::Size arg2 ;
78347   Dali::Size *argp2 ;
78348
78349   arg1 = (Dali::Toolkit::TableView *)jarg1;
78350   argp2 = (Dali::Size *)jarg2;
78351   if (!argp2) {
78352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
78353     return ;
78354   }
78355   arg2 = *argp2;
78356   {
78357     try {
78358       (arg1)->SetCellPadding(arg2);
78359     } catch (std::out_of_range& e) {
78360       {
78361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78362       };
78363     } catch (std::exception& e) {
78364       {
78365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78366       };
78367     } catch (Dali::DaliException e) {
78368       {
78369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78370       };
78371     } catch (...) {
78372       {
78373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78374       };
78375     }
78376   }
78377
78378 }
78379
78380
78381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
78382   void * jresult ;
78383   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78384   Dali::Size result;
78385
78386   arg1 = (Dali::Toolkit::TableView *)jarg1;
78387   {
78388     try {
78389       result = (arg1)->GetCellPadding();
78390     } catch (std::out_of_range& e) {
78391       {
78392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78393       };
78394     } catch (std::exception& e) {
78395       {
78396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78397       };
78398     } catch (Dali::DaliException e) {
78399       {
78400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78401       };
78402     } catch (...) {
78403       {
78404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78405       };
78406     }
78407   }
78408
78409   jresult = new Dali::Size((const Dali::Size &)result);
78410   return jresult;
78411 }
78412
78413
78414 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
78415   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78416   unsigned int arg2 ;
78417
78418   arg1 = (Dali::Toolkit::TableView *)jarg1;
78419   arg2 = (unsigned int)jarg2;
78420   {
78421     try {
78422       (arg1)->SetFitHeight(arg2);
78423     } catch (std::out_of_range& e) {
78424       {
78425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78426       };
78427     } catch (std::exception& e) {
78428       {
78429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78430       };
78431     } catch (Dali::DaliException e) {
78432       {
78433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78434       };
78435     } catch (...) {
78436       {
78437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78438       };
78439     }
78440   }
78441
78442 }
78443
78444
78445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
78446   unsigned int jresult ;
78447   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78448   unsigned int arg2 ;
78449   bool result;
78450
78451   arg1 = (Dali::Toolkit::TableView *)jarg1;
78452   arg2 = (unsigned int)jarg2;
78453   {
78454     try {
78455       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
78456     } catch (std::out_of_range& e) {
78457       {
78458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78459       };
78460     } catch (std::exception& e) {
78461       {
78462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78463       };
78464     } catch (Dali::DaliException e) {
78465       {
78466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78467       };
78468     } catch (...) {
78469       {
78470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78471       };
78472     }
78473   }
78474
78475   jresult = result;
78476   return jresult;
78477 }
78478
78479
78480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
78481   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78482   unsigned int arg2 ;
78483
78484   arg1 = (Dali::Toolkit::TableView *)jarg1;
78485   arg2 = (unsigned int)jarg2;
78486   {
78487     try {
78488       (arg1)->SetFitWidth(arg2);
78489     } catch (std::out_of_range& e) {
78490       {
78491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78492       };
78493     } catch (std::exception& e) {
78494       {
78495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78496       };
78497     } catch (Dali::DaliException e) {
78498       {
78499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78500       };
78501     } catch (...) {
78502       {
78503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78504       };
78505     }
78506   }
78507
78508 }
78509
78510
78511 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78512   unsigned int jresult ;
78513   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78514   unsigned int arg2 ;
78515   bool result;
78516
78517   arg1 = (Dali::Toolkit::TableView *)jarg1;
78518   arg2 = (unsigned int)jarg2;
78519   {
78520     try {
78521       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78522     } catch (std::out_of_range& e) {
78523       {
78524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78525       };
78526     } catch (std::exception& e) {
78527       {
78528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78529       };
78530     } catch (Dali::DaliException e) {
78531       {
78532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78533       };
78534     } catch (...) {
78535       {
78536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78537       };
78538     }
78539   }
78540
78541   jresult = result;
78542   return jresult;
78543 }
78544
78545
78546 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78547   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78548   unsigned int arg2 ;
78549   float arg3 ;
78550
78551   arg1 = (Dali::Toolkit::TableView *)jarg1;
78552   arg2 = (unsigned int)jarg2;
78553   arg3 = (float)jarg3;
78554   {
78555     try {
78556       (arg1)->SetFixedHeight(arg2,arg3);
78557     } catch (std::out_of_range& e) {
78558       {
78559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78560       };
78561     } catch (std::exception& e) {
78562       {
78563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78564       };
78565     } catch (Dali::DaliException e) {
78566       {
78567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78568       };
78569     } catch (...) {
78570       {
78571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78572       };
78573     }
78574   }
78575
78576 }
78577
78578
78579 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78580   float jresult ;
78581   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78582   unsigned int arg2 ;
78583   float result;
78584
78585   arg1 = (Dali::Toolkit::TableView *)jarg1;
78586   arg2 = (unsigned int)jarg2;
78587   {
78588     try {
78589       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78590     } catch (std::out_of_range& e) {
78591       {
78592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78593       };
78594     } catch (std::exception& e) {
78595       {
78596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78597       };
78598     } catch (Dali::DaliException e) {
78599       {
78600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78601       };
78602     } catch (...) {
78603       {
78604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78605       };
78606     }
78607   }
78608
78609   jresult = result;
78610   return jresult;
78611 }
78612
78613
78614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78615   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78616   unsigned int arg2 ;
78617   float arg3 ;
78618
78619   arg1 = (Dali::Toolkit::TableView *)jarg1;
78620   arg2 = (unsigned int)jarg2;
78621   arg3 = (float)jarg3;
78622   {
78623     try {
78624       (arg1)->SetRelativeHeight(arg2,arg3);
78625     } catch (std::out_of_range& e) {
78626       {
78627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78628       };
78629     } catch (std::exception& e) {
78630       {
78631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78632       };
78633     } catch (Dali::DaliException e) {
78634       {
78635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78636       };
78637     } catch (...) {
78638       {
78639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78640       };
78641     }
78642   }
78643
78644 }
78645
78646
78647 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78648   float jresult ;
78649   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78650   unsigned int arg2 ;
78651   float result;
78652
78653   arg1 = (Dali::Toolkit::TableView *)jarg1;
78654   arg2 = (unsigned int)jarg2;
78655   {
78656     try {
78657       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78658     } catch (std::out_of_range& e) {
78659       {
78660         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78661       };
78662     } catch (std::exception& e) {
78663       {
78664         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78665       };
78666     } catch (Dali::DaliException e) {
78667       {
78668         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78669       };
78670     } catch (...) {
78671       {
78672         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78673       };
78674     }
78675   }
78676
78677   jresult = result;
78678   return jresult;
78679 }
78680
78681
78682 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78683   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78684   unsigned int arg2 ;
78685   float arg3 ;
78686
78687   arg1 = (Dali::Toolkit::TableView *)jarg1;
78688   arg2 = (unsigned int)jarg2;
78689   arg3 = (float)jarg3;
78690   {
78691     try {
78692       (arg1)->SetFixedWidth(arg2,arg3);
78693     } catch (std::out_of_range& e) {
78694       {
78695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78696       };
78697     } catch (std::exception& e) {
78698       {
78699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78700       };
78701     } catch (Dali::DaliException e) {
78702       {
78703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78704       };
78705     } catch (...) {
78706       {
78707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78708       };
78709     }
78710   }
78711
78712 }
78713
78714
78715 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78716   float jresult ;
78717   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78718   unsigned int arg2 ;
78719   float result;
78720
78721   arg1 = (Dali::Toolkit::TableView *)jarg1;
78722   arg2 = (unsigned int)jarg2;
78723   {
78724     try {
78725       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78726     } catch (std::out_of_range& e) {
78727       {
78728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78729       };
78730     } catch (std::exception& e) {
78731       {
78732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78733       };
78734     } catch (Dali::DaliException e) {
78735       {
78736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78737       };
78738     } catch (...) {
78739       {
78740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78741       };
78742     }
78743   }
78744
78745   jresult = result;
78746   return jresult;
78747 }
78748
78749
78750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78751   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78752   unsigned int arg2 ;
78753   float arg3 ;
78754
78755   arg1 = (Dali::Toolkit::TableView *)jarg1;
78756   arg2 = (unsigned int)jarg2;
78757   arg3 = (float)jarg3;
78758   {
78759     try {
78760       (arg1)->SetRelativeWidth(arg2,arg3);
78761     } catch (std::out_of_range& e) {
78762       {
78763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78764       };
78765     } catch (std::exception& e) {
78766       {
78767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78768       };
78769     } catch (Dali::DaliException e) {
78770       {
78771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78772       };
78773     } catch (...) {
78774       {
78775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78776       };
78777     }
78778   }
78779
78780 }
78781
78782
78783 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78784   float jresult ;
78785   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78786   unsigned int arg2 ;
78787   float result;
78788
78789   arg1 = (Dali::Toolkit::TableView *)jarg1;
78790   arg2 = (unsigned int)jarg2;
78791   {
78792     try {
78793       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78794     } catch (std::out_of_range& e) {
78795       {
78796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78797       };
78798     } catch (std::exception& e) {
78799       {
78800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78801       };
78802     } catch (Dali::DaliException e) {
78803       {
78804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78805       };
78806     } catch (...) {
78807       {
78808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78809       };
78810     }
78811   }
78812
78813   jresult = result;
78814   return jresult;
78815 }
78816
78817
78818 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78819   unsigned int jresult ;
78820   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78821   unsigned int result;
78822
78823   arg1 = (Dali::Toolkit::TableView *)jarg1;
78824   {
78825     try {
78826       result = (unsigned int)(arg1)->GetRows();
78827     } catch (std::out_of_range& e) {
78828       {
78829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78830       };
78831     } catch (std::exception& e) {
78832       {
78833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78834       };
78835     } catch (Dali::DaliException e) {
78836       {
78837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78838       };
78839     } catch (...) {
78840       {
78841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78842       };
78843     }
78844   }
78845
78846   jresult = result;
78847   return jresult;
78848 }
78849
78850
78851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78852   unsigned int jresult ;
78853   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78854   unsigned int result;
78855
78856   arg1 = (Dali::Toolkit::TableView *)jarg1;
78857   {
78858     try {
78859       result = (unsigned int)(arg1)->GetColumns();
78860     } catch (std::out_of_range& e) {
78861       {
78862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78863       };
78864     } catch (std::exception& e) {
78865       {
78866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78867       };
78868     } catch (Dali::DaliException e) {
78869       {
78870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78871       };
78872     } catch (...) {
78873       {
78874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78875       };
78876     }
78877   }
78878
78879   jresult = result;
78880   return jresult;
78881 }
78882
78883
78884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78885   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78886   Dali::Toolkit::TableView::CellPosition arg2 ;
78887   Dali::HorizontalAlignment::Type arg3 ;
78888   Dali::VerticalAlignment::Type arg4 ;
78889   Dali::Toolkit::TableView::CellPosition *argp2 ;
78890
78891   arg1 = (Dali::Toolkit::TableView *)jarg1;
78892   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78893   if (!argp2) {
78894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78895     return ;
78896   }
78897   arg2 = *argp2;
78898   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78899   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78900   {
78901     try {
78902       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78903     } catch (std::out_of_range& e) {
78904       {
78905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78906       };
78907     } catch (std::exception& e) {
78908       {
78909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78910       };
78911     } catch (Dali::DaliException e) {
78912       {
78913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78914       };
78915     } catch (...) {
78916       {
78917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78918       };
78919     }
78920   }
78921
78922 }
78923
78924
78925 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78926   unsigned int jresult ;
78927   unsigned int result;
78928
78929   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78930   jresult = result;
78931   return jresult;
78932 }
78933
78934
78935 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78936   int jresult ;
78937   int result;
78938
78939   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78940   jresult = (int)result;
78941   return jresult;
78942 }
78943
78944
78945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78946   int jresult ;
78947   int result;
78948
78949   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78950   jresult = (int)result;
78951   return jresult;
78952 }
78953
78954
78955 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78956   int jresult ;
78957   int result;
78958
78959   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78960   jresult = (int)result;
78961   return jresult;
78962 }
78963
78964
78965 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78966   int jresult ;
78967   int result;
78968
78969   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78970   jresult = (int)result;
78971   return jresult;
78972 }
78973
78974
78975 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78976   int jresult ;
78977   int result;
78978
78979   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78980   jresult = (int)result;
78981   return jresult;
78982 }
78983
78984
78985 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78986   int jresult ;
78987   int result;
78988
78989   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78990   jresult = (int)result;
78991   return jresult;
78992 }
78993
78994
78995 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78996   int jresult ;
78997   int result;
78998
78999   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
79000   jresult = (int)result;
79001   return jresult;
79002 }
79003
79004
79005 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
79006   int jresult ;
79007   int result;
79008
79009   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
79010   jresult = (int)result;
79011   return jresult;
79012 }
79013
79014
79015 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
79016   int jresult ;
79017   int result;
79018
79019   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
79020   jresult = (int)result;
79021   return jresult;
79022 }
79023
79024
79025 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
79026   int jresult ;
79027   int result;
79028
79029   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
79030   jresult = (int)result;
79031   return jresult;
79032 }
79033
79034
79035 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
79036   int jresult ;
79037   int result;
79038
79039   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
79040   jresult = (int)result;
79041   return jresult;
79042 }
79043
79044
79045 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
79046   int jresult ;
79047   int result;
79048
79049   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
79050   jresult = (int)result;
79051   return jresult;
79052 }
79053
79054
79055 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
79056   int jresult ;
79057   int result;
79058
79059   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
79060   jresult = (int)result;
79061   return jresult;
79062 }
79063
79064
79065 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
79066   int jresult ;
79067   int result;
79068
79069   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
79070   jresult = (int)result;
79071   return jresult;
79072 }
79073
79074
79075 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
79076   int jresult ;
79077   int result;
79078
79079   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
79080   jresult = (int)result;
79081   return jresult;
79082 }
79083
79084
79085 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
79086   int jresult ;
79087   int result;
79088
79089   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
79090   jresult = (int)result;
79091   return jresult;
79092 }
79093
79094
79095 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
79096   int jresult ;
79097   int result;
79098
79099   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
79100   jresult = (int)result;
79101   return jresult;
79102 }
79103
79104
79105 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
79106   int jresult ;
79107   int result;
79108
79109   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
79110   jresult = (int)result;
79111   return jresult;
79112 }
79113
79114
79115 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
79116   void * jresult ;
79117   Dali::Toolkit::TextLabel::Property *result = 0 ;
79118
79119   {
79120     try {
79121       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
79122     } catch (std::out_of_range& e) {
79123       {
79124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79125       };
79126     } catch (std::exception& e) {
79127       {
79128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79129       };
79130     } catch (Dali::DaliException e) {
79131       {
79132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79133       };
79134     } catch (...) {
79135       {
79136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79137       };
79138     }
79139   }
79140
79141   jresult = (void *)result;
79142   return jresult;
79143 }
79144
79145
79146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
79147   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
79148
79149   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
79150   {
79151     try {
79152       delete arg1;
79153     } catch (std::out_of_range& e) {
79154       {
79155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79156       };
79157     } catch (std::exception& e) {
79158       {
79159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79160       };
79161     } catch (Dali::DaliException e) {
79162       {
79163         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79164       };
79165     } catch (...) {
79166       {
79167         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79168       };
79169     }
79170   }
79171
79172 }
79173
79174
79175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
79176   void * jresult ;
79177   Dali::Toolkit::TextLabel result;
79178
79179   {
79180     try {
79181       result = Dali::Toolkit::TextLabel::New();
79182     } catch (std::out_of_range& e) {
79183       {
79184         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79185       };
79186     } catch (std::exception& e) {
79187       {
79188         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79189       };
79190     } catch (Dali::DaliException e) {
79191       {
79192         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79193       };
79194     } catch (...) {
79195       {
79196         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79197       };
79198     }
79199   }
79200
79201   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79202   return jresult;
79203 }
79204
79205
79206 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
79207   void * jresult ;
79208   std::string *arg1 = 0 ;
79209   Dali::Toolkit::TextLabel result;
79210
79211   if (!jarg1) {
79212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79213     return 0;
79214   }
79215   std::string arg1_str(jarg1);
79216   arg1 = &arg1_str;
79217   {
79218     try {
79219       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
79220     } catch (std::out_of_range& e) {
79221       {
79222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79223       };
79224     } catch (std::exception& e) {
79225       {
79226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79227       };
79228     } catch (Dali::DaliException e) {
79229       {
79230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79231       };
79232     } catch (...) {
79233       {
79234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79235       };
79236     }
79237   }
79238
79239   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79240
79241   //argout typemap for const std::string&
79242
79243   return jresult;
79244 }
79245
79246
79247 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
79248   void * jresult ;
79249   Dali::Toolkit::TextLabel *result = 0 ;
79250
79251   {
79252     try {
79253       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
79254     } catch (std::out_of_range& e) {
79255       {
79256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79257       };
79258     } catch (std::exception& e) {
79259       {
79260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79261       };
79262     } catch (Dali::DaliException e) {
79263       {
79264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79265       };
79266     } catch (...) {
79267       {
79268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79269       };
79270     }
79271   }
79272
79273   jresult = (void *)result;
79274   return jresult;
79275 }
79276
79277
79278 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
79279   void * jresult ;
79280   Dali::Toolkit::TextLabel *arg1 = 0 ;
79281   Dali::Toolkit::TextLabel *result = 0 ;
79282
79283   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79284   if (!arg1) {
79285     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79286     return 0;
79287   }
79288   {
79289     try {
79290       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
79291     } catch (std::out_of_range& e) {
79292       {
79293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79294       };
79295     } catch (std::exception& e) {
79296       {
79297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79298       };
79299     } catch (Dali::DaliException e) {
79300       {
79301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79302       };
79303     } catch (...) {
79304       {
79305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79306       };
79307     }
79308   }
79309
79310   jresult = (void *)result;
79311   return jresult;
79312 }
79313
79314
79315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
79316   void * jresult ;
79317   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79318   Dali::Toolkit::TextLabel *arg2 = 0 ;
79319   Dali::Toolkit::TextLabel *result = 0 ;
79320
79321   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79322   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
79323   if (!arg2) {
79324     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
79325     return 0;
79326   }
79327   {
79328     try {
79329       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
79330     } catch (std::out_of_range& e) {
79331       {
79332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79333       };
79334     } catch (std::exception& e) {
79335       {
79336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79337       };
79338     } catch (Dali::DaliException e) {
79339       {
79340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79341       };
79342     } catch (...) {
79343       {
79344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79345       };
79346     }
79347   }
79348
79349   jresult = (void *)result;
79350   return jresult;
79351 }
79352
79353
79354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
79355   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
79356
79357   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
79358   {
79359     try {
79360       delete arg1;
79361     } catch (std::out_of_range& e) {
79362       {
79363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79364       };
79365     } catch (std::exception& e) {
79366       {
79367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79368       };
79369     } catch (Dali::DaliException e) {
79370       {
79371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79372       };
79373     } catch (...) {
79374       {
79375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79376       };
79377     }
79378   }
79379
79380 }
79381
79382
79383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
79384   void * jresult ;
79385   Dali::BaseHandle arg1 ;
79386   Dali::BaseHandle *argp1 ;
79387   Dali::Toolkit::TextLabel result;
79388
79389   argp1 = (Dali::BaseHandle *)jarg1;
79390   if (!argp1) {
79391     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
79392     return 0;
79393   }
79394   arg1 = *argp1;
79395   {
79396     try {
79397       result = Dali::Toolkit::TextLabel::DownCast(arg1);
79398     } catch (std::out_of_range& e) {
79399       {
79400         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79401       };
79402     } catch (std::exception& e) {
79403       {
79404         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79405       };
79406     } catch (Dali::DaliException e) {
79407       {
79408         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79409       };
79410     } catch (...) {
79411       {
79412         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79413       };
79414     }
79415   }
79416
79417   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
79418   return jresult;
79419 }
79420
79421
79422 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
79423   void * jresult ;
79424   Dali::Toolkit::AccessibilityManager *result = 0 ;
79425
79426   {
79427     try {
79428       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
79429     } catch (std::out_of_range& e) {
79430       {
79431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79432       };
79433     } catch (std::exception& e) {
79434       {
79435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79436       };
79437     } catch (Dali::DaliException e) {
79438       {
79439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79440       };
79441     } catch (...) {
79442       {
79443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79444       };
79445     }
79446   }
79447
79448   jresult = (void *)result;
79449   return jresult;
79450 }
79451
79452
79453 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
79454   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79455
79456   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79457   {
79458     try {
79459       delete arg1;
79460     } catch (std::out_of_range& e) {
79461       {
79462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79463       };
79464     } catch (std::exception& e) {
79465       {
79466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79467       };
79468     } catch (Dali::DaliException e) {
79469       {
79470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79471       };
79472     } catch (...) {
79473       {
79474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79475       };
79476     }
79477   }
79478
79479 }
79480
79481
79482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
79483   void * jresult ;
79484   Dali::Toolkit::AccessibilityManager result;
79485
79486   {
79487     try {
79488       result = Dali::Toolkit::AccessibilityManager::Get();
79489     } catch (std::out_of_range& e) {
79490       {
79491         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79492       };
79493     } catch (std::exception& e) {
79494       {
79495         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79496       };
79497     } catch (Dali::DaliException e) {
79498       {
79499         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79500       };
79501     } catch (...) {
79502       {
79503         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79504       };
79505     }
79506   }
79507
79508   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79509   return jresult;
79510 }
79511
79512
79513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79514   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79515   Dali::Actor arg2 ;
79516   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79517   std::string *arg4 = 0 ;
79518   Dali::Actor *argp2 ;
79519
79520   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79521   argp2 = (Dali::Actor *)jarg2;
79522   if (!argp2) {
79523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79524     return ;
79525   }
79526   arg2 = *argp2;
79527   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79528   if (!jarg4) {
79529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79530     return ;
79531   }
79532   std::string arg4_str(jarg4);
79533   arg4 = &arg4_str;
79534   {
79535     try {
79536       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79537     } catch (std::out_of_range& e) {
79538       {
79539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79540       };
79541     } catch (std::exception& e) {
79542       {
79543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79544       };
79545     } catch (Dali::DaliException e) {
79546       {
79547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79548       };
79549     } catch (...) {
79550       {
79551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79552       };
79553     }
79554   }
79555
79556
79557   //argout typemap for const std::string&
79558
79559 }
79560
79561
79562 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79563   char * jresult ;
79564   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79565   Dali::Actor arg2 ;
79566   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79567   Dali::Actor *argp2 ;
79568   std::string result;
79569
79570   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79571   argp2 = (Dali::Actor *)jarg2;
79572   if (!argp2) {
79573     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79574     return 0;
79575   }
79576   arg2 = *argp2;
79577   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79578   {
79579     try {
79580       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79581     } catch (std::out_of_range& e) {
79582       {
79583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79584       };
79585     } catch (std::exception& e) {
79586       {
79587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79588       };
79589     } catch (Dali::DaliException e) {
79590       {
79591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79592       };
79593     } catch (...) {
79594       {
79595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79596       };
79597     }
79598   }
79599
79600   jresult = SWIG_csharp_string_callback((&result)->c_str());
79601   return jresult;
79602 }
79603
79604
79605 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79606   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79607   Dali::Actor arg2 ;
79608   unsigned int arg3 ;
79609   Dali::Actor *argp2 ;
79610
79611   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79612   argp2 = (Dali::Actor *)jarg2;
79613   if (!argp2) {
79614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79615     return ;
79616   }
79617   arg2 = *argp2;
79618   arg3 = (unsigned int)jarg3;
79619   {
79620     try {
79621       (arg1)->SetFocusOrder(arg2,arg3);
79622     } catch (std::out_of_range& e) {
79623       {
79624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79625       };
79626     } catch (std::exception& e) {
79627       {
79628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79629       };
79630     } catch (Dali::DaliException e) {
79631       {
79632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79633       };
79634     } catch (...) {
79635       {
79636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79637       };
79638     }
79639   }
79640
79641 }
79642
79643
79644 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79645   unsigned int jresult ;
79646   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79647   Dali::Actor arg2 ;
79648   Dali::Actor *argp2 ;
79649   unsigned int result;
79650
79651   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79652   argp2 = (Dali::Actor *)jarg2;
79653   if (!argp2) {
79654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79655     return 0;
79656   }
79657   arg2 = *argp2;
79658   {
79659     try {
79660       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79661     } catch (std::out_of_range& e) {
79662       {
79663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79664       };
79665     } catch (std::exception& e) {
79666       {
79667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79668       };
79669     } catch (Dali::DaliException e) {
79670       {
79671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79672       };
79673     } catch (...) {
79674       {
79675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79676       };
79677     }
79678   }
79679
79680   jresult = result;
79681   return jresult;
79682 }
79683
79684
79685 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79686   unsigned int jresult ;
79687   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79688   unsigned int result;
79689
79690   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79691   {
79692     try {
79693       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79694     } catch (std::out_of_range& e) {
79695       {
79696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79697       };
79698     } catch (std::exception& e) {
79699       {
79700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79701       };
79702     } catch (Dali::DaliException e) {
79703       {
79704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79705       };
79706     } catch (...) {
79707       {
79708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79709       };
79710     }
79711   }
79712
79713   jresult = result;
79714   return jresult;
79715 }
79716
79717
79718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79719   void * jresult ;
79720   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79721   unsigned int arg2 ;
79722   Dali::Actor result;
79723
79724   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79725   arg2 = (unsigned int)jarg2;
79726   {
79727     try {
79728       result = (arg1)->GetActorByFocusOrder(arg2);
79729     } catch (std::out_of_range& e) {
79730       {
79731         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79732       };
79733     } catch (std::exception& e) {
79734       {
79735         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79736       };
79737     } catch (Dali::DaliException e) {
79738       {
79739         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79740       };
79741     } catch (...) {
79742       {
79743         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79744       };
79745     }
79746   }
79747
79748   jresult = new Dali::Actor((const Dali::Actor &)result);
79749   return jresult;
79750 }
79751
79752
79753 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79754   unsigned int jresult ;
79755   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79756   Dali::Actor arg2 ;
79757   Dali::Actor *argp2 ;
79758   bool result;
79759
79760   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79761   argp2 = (Dali::Actor *)jarg2;
79762   if (!argp2) {
79763     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79764     return 0;
79765   }
79766   arg2 = *argp2;
79767   {
79768     try {
79769       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79770     } catch (std::out_of_range& e) {
79771       {
79772         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79773       };
79774     } catch (std::exception& e) {
79775       {
79776         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79777       };
79778     } catch (Dali::DaliException e) {
79779       {
79780         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79781       };
79782     } catch (...) {
79783       {
79784         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79785       };
79786     }
79787   }
79788
79789   jresult = result;
79790   return jresult;
79791 }
79792
79793
79794 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79795   void * jresult ;
79796   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79797   Dali::Actor result;
79798
79799   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79800   {
79801     try {
79802       result = (arg1)->GetCurrentFocusActor();
79803     } catch (std::out_of_range& e) {
79804       {
79805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79806       };
79807     } catch (std::exception& e) {
79808       {
79809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79810       };
79811     } catch (Dali::DaliException e) {
79812       {
79813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79814       };
79815     } catch (...) {
79816       {
79817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79818       };
79819     }
79820   }
79821
79822   jresult = new Dali::Actor((const Dali::Actor &)result);
79823   return jresult;
79824 }
79825
79826
79827 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79828   void * jresult ;
79829   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79830   Dali::Actor result;
79831
79832   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79833   {
79834     try {
79835       result = (arg1)->GetCurrentFocusGroup();
79836     } catch (std::out_of_range& e) {
79837       {
79838         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79839       };
79840     } catch (std::exception& e) {
79841       {
79842         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79843       };
79844     } catch (Dali::DaliException e) {
79845       {
79846         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79847       };
79848     } catch (...) {
79849       {
79850         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79851       };
79852     }
79853   }
79854
79855   jresult = new Dali::Actor((const Dali::Actor &)result);
79856   return jresult;
79857 }
79858
79859
79860 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79861   unsigned int jresult ;
79862   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79863   unsigned int result;
79864
79865   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79866   {
79867     try {
79868       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79869     } catch (std::out_of_range& e) {
79870       {
79871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79872       };
79873     } catch (std::exception& e) {
79874       {
79875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79876       };
79877     } catch (Dali::DaliException e) {
79878       {
79879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79880       };
79881     } catch (...) {
79882       {
79883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79884       };
79885     }
79886   }
79887
79888   jresult = result;
79889   return jresult;
79890 }
79891
79892
79893 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79894   unsigned int jresult ;
79895   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79896   bool result;
79897
79898   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79899   {
79900     try {
79901       result = (bool)(arg1)->MoveFocusForward();
79902     } catch (std::out_of_range& e) {
79903       {
79904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79905       };
79906     } catch (std::exception& e) {
79907       {
79908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79909       };
79910     } catch (Dali::DaliException e) {
79911       {
79912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79913       };
79914     } catch (...) {
79915       {
79916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79917       };
79918     }
79919   }
79920
79921   jresult = result;
79922   return jresult;
79923 }
79924
79925
79926 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79927   unsigned int jresult ;
79928   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79929   bool result;
79930
79931   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79932   {
79933     try {
79934       result = (bool)(arg1)->MoveFocusBackward();
79935     } catch (std::out_of_range& e) {
79936       {
79937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79938       };
79939     } catch (std::exception& e) {
79940       {
79941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79942       };
79943     } catch (Dali::DaliException e) {
79944       {
79945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79946       };
79947     } catch (...) {
79948       {
79949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79950       };
79951     }
79952   }
79953
79954   jresult = result;
79955   return jresult;
79956 }
79957
79958
79959 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79960   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79961
79962   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79963   {
79964     try {
79965       (arg1)->ClearFocus();
79966     } catch (std::out_of_range& e) {
79967       {
79968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79969       };
79970     } catch (std::exception& e) {
79971       {
79972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79973       };
79974     } catch (Dali::DaliException e) {
79975       {
79976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79977       };
79978     } catch (...) {
79979       {
79980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79981       };
79982     }
79983   }
79984
79985 }
79986
79987
79988 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79989   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79990
79991   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79992   {
79993     try {
79994       (arg1)->Reset();
79995     } catch (std::out_of_range& e) {
79996       {
79997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79998       };
79999     } catch (std::exception& e) {
80000       {
80001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80002       };
80003     } catch (Dali::DaliException e) {
80004       {
80005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80006       };
80007     } catch (...) {
80008       {
80009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80010       };
80011     }
80012   }
80013
80014 }
80015
80016
80017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
80018   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80019   Dali::Actor arg2 ;
80020   bool arg3 ;
80021   Dali::Actor *argp2 ;
80022
80023   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80024   argp2 = (Dali::Actor *)jarg2;
80025   if (!argp2) {
80026     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80027     return ;
80028   }
80029   arg2 = *argp2;
80030   arg3 = jarg3 ? true : false;
80031   {
80032     try {
80033       (arg1)->SetFocusGroup(arg2,arg3);
80034     } catch (std::out_of_range& e) {
80035       {
80036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80037       };
80038     } catch (std::exception& e) {
80039       {
80040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80041       };
80042     } catch (Dali::DaliException e) {
80043       {
80044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80045       };
80046     } catch (...) {
80047       {
80048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80049       };
80050     }
80051   }
80052
80053 }
80054
80055
80056 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
80057   unsigned int jresult ;
80058   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80059   Dali::Actor arg2 ;
80060   Dali::Actor *argp2 ;
80061   bool result;
80062
80063   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80064   argp2 = (Dali::Actor *)jarg2;
80065   if (!argp2) {
80066     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80067     return 0;
80068   }
80069   arg2 = *argp2;
80070   {
80071     try {
80072       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
80073     } catch (std::out_of_range& e) {
80074       {
80075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80076       };
80077     } catch (std::exception& e) {
80078       {
80079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80080       };
80081     } catch (Dali::DaliException e) {
80082       {
80083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80084       };
80085     } catch (...) {
80086       {
80087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80088       };
80089     }
80090   }
80091
80092   jresult = result;
80093   return jresult;
80094 }
80095
80096
80097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
80098   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80099   bool arg2 ;
80100
80101   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80102   arg2 = jarg2 ? true : false;
80103   {
80104     try {
80105       (arg1)->SetGroupMode(arg2);
80106     } catch (std::out_of_range& e) {
80107       {
80108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80109       };
80110     } catch (std::exception& e) {
80111       {
80112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80113       };
80114     } catch (Dali::DaliException e) {
80115       {
80116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80117       };
80118     } catch (...) {
80119       {
80120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80121       };
80122     }
80123   }
80124
80125 }
80126
80127
80128 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
80129   unsigned int jresult ;
80130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80131   bool result;
80132
80133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80134   {
80135     try {
80136       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
80137     } catch (std::out_of_range& e) {
80138       {
80139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80140       };
80141     } catch (std::exception& e) {
80142       {
80143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80144       };
80145     } catch (Dali::DaliException e) {
80146       {
80147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80148       };
80149     } catch (...) {
80150       {
80151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80152       };
80153     }
80154   }
80155
80156   jresult = result;
80157   return jresult;
80158 }
80159
80160
80161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
80162   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80163   bool arg2 ;
80164
80165   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80166   arg2 = jarg2 ? true : false;
80167   {
80168     try {
80169       (arg1)->SetWrapMode(arg2);
80170     } catch (std::out_of_range& e) {
80171       {
80172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80173       };
80174     } catch (std::exception& e) {
80175       {
80176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80177       };
80178     } catch (Dali::DaliException e) {
80179       {
80180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80181       };
80182     } catch (...) {
80183       {
80184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80185       };
80186     }
80187   }
80188
80189 }
80190
80191
80192 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
80193   unsigned int jresult ;
80194   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80195   bool result;
80196
80197   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80198   {
80199     try {
80200       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
80201     } catch (std::out_of_range& e) {
80202       {
80203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80204       };
80205     } catch (std::exception& e) {
80206       {
80207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80208       };
80209     } catch (Dali::DaliException e) {
80210       {
80211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80212       };
80213     } catch (...) {
80214       {
80215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80216       };
80217     }
80218   }
80219
80220   jresult = result;
80221   return jresult;
80222 }
80223
80224
80225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
80226   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80227   Dali::Actor arg2 ;
80228   Dali::Actor *argp2 ;
80229
80230   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80231   argp2 = (Dali::Actor *)jarg2;
80232   if (!argp2) {
80233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80234     return ;
80235   }
80236   arg2 = *argp2;
80237   {
80238     try {
80239       (arg1)->SetFocusIndicatorActor(arg2);
80240     } catch (std::out_of_range& e) {
80241       {
80242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80243       };
80244     } catch (std::exception& e) {
80245       {
80246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80247       };
80248     } catch (Dali::DaliException e) {
80249       {
80250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80251       };
80252     } catch (...) {
80253       {
80254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80255       };
80256     }
80257   }
80258
80259 }
80260
80261
80262 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
80263   void * jresult ;
80264   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80265   Dali::Actor result;
80266
80267   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80268   {
80269     try {
80270       result = (arg1)->GetFocusIndicatorActor();
80271     } catch (std::out_of_range& e) {
80272       {
80273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80274       };
80275     } catch (std::exception& e) {
80276       {
80277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80278       };
80279     } catch (Dali::DaliException e) {
80280       {
80281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80282       };
80283     } catch (...) {
80284       {
80285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80286       };
80287     }
80288   }
80289
80290   jresult = new Dali::Actor((const Dali::Actor &)result);
80291   return jresult;
80292 }
80293
80294
80295 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
80296   void * jresult ;
80297   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80298   Dali::Actor arg2 ;
80299   Dali::Actor *argp2 ;
80300   Dali::Actor result;
80301
80302   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80303   argp2 = (Dali::Actor *)jarg2;
80304   if (!argp2) {
80305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
80306     return 0;
80307   }
80308   arg2 = *argp2;
80309   {
80310     try {
80311       result = (arg1)->GetFocusGroup(arg2);
80312     } catch (std::out_of_range& e) {
80313       {
80314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80315       };
80316     } catch (std::exception& e) {
80317       {
80318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80319       };
80320     } catch (Dali::DaliException e) {
80321       {
80322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80323       };
80324     } catch (...) {
80325       {
80326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80327       };
80328     }
80329   }
80330
80331   jresult = new Dali::Actor((const Dali::Actor &)result);
80332   return jresult;
80333 }
80334
80335
80336 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
80337   void * jresult ;
80338   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80339   Dali::Vector2 result;
80340
80341   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80342   {
80343     try {
80344       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
80345     } catch (std::out_of_range& e) {
80346       {
80347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80348       };
80349     } catch (std::exception& e) {
80350       {
80351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80352       };
80353     } catch (Dali::DaliException e) {
80354       {
80355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80356       };
80357     } catch (...) {
80358       {
80359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80360       };
80361     }
80362   }
80363
80364   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
80365   return jresult;
80366 }
80367
80368
80369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
80370   void * jresult ;
80371   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80372   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
80373
80374   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80375   {
80376     try {
80377       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
80378     } catch (std::out_of_range& e) {
80379       {
80380         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80381       };
80382     } catch (std::exception& e) {
80383       {
80384         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80385       };
80386     } catch (Dali::DaliException e) {
80387       {
80388         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80389       };
80390     } catch (...) {
80391       {
80392         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80393       };
80394     }
80395   }
80396
80397   jresult = (void *)result;
80398   return jresult;
80399 }
80400
80401
80402 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
80403   void * jresult ;
80404   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80405   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
80406
80407   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80408   {
80409     try {
80410       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
80411     } catch (std::out_of_range& e) {
80412       {
80413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80414       };
80415     } catch (std::exception& e) {
80416       {
80417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80418       };
80419     } catch (Dali::DaliException e) {
80420       {
80421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80422       };
80423     } catch (...) {
80424       {
80425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80426       };
80427     }
80428   }
80429
80430   jresult = (void *)result;
80431   return jresult;
80432 }
80433
80434
80435 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
80436   void * jresult ;
80437   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80438   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
80439
80440   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80441   {
80442     try {
80443       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
80444     } catch (std::out_of_range& e) {
80445       {
80446         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80447       };
80448     } catch (std::exception& e) {
80449       {
80450         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80451       };
80452     } catch (Dali::DaliException e) {
80453       {
80454         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80455       };
80456     } catch (...) {
80457       {
80458         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80459       };
80460     }
80461   }
80462
80463   jresult = (void *)result;
80464   return jresult;
80465 }
80466
80467
80468 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
80469   void * jresult ;
80470   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80471   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80472
80473   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80474   {
80475     try {
80476       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
80477     } catch (std::out_of_range& e) {
80478       {
80479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80480       };
80481     } catch (std::exception& e) {
80482       {
80483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80484       };
80485     } catch (Dali::DaliException e) {
80486       {
80487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80488       };
80489     } catch (...) {
80490       {
80491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80492       };
80493     }
80494   }
80495
80496   jresult = (void *)result;
80497   return jresult;
80498 }
80499
80500
80501 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80502   void * jresult ;
80503   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80504   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80505
80506   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80507   {
80508     try {
80509       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80510     } catch (std::out_of_range& e) {
80511       {
80512         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80513       };
80514     } catch (std::exception& e) {
80515       {
80516         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80517       };
80518     } catch (Dali::DaliException e) {
80519       {
80520         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80521       };
80522     } catch (...) {
80523       {
80524         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80525       };
80526     }
80527   }
80528
80529   jresult = (void *)result;
80530   return jresult;
80531 }
80532
80533
80534 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80535   void * jresult ;
80536   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80537   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80538
80539   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80540   {
80541     try {
80542       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80543     } catch (std::out_of_range& e) {
80544       {
80545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80546       };
80547     } catch (std::exception& e) {
80548       {
80549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80550       };
80551     } catch (Dali::DaliException e) {
80552       {
80553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80554       };
80555     } catch (...) {
80556       {
80557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80558       };
80559     }
80560   }
80561
80562   jresult = (void *)result;
80563   return jresult;
80564 }
80565
80566
80567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80568   void * jresult ;
80569   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80570   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80571
80572   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80573   {
80574     try {
80575       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80576     } catch (std::out_of_range& e) {
80577       {
80578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80579       };
80580     } catch (std::exception& e) {
80581       {
80582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80583       };
80584     } catch (Dali::DaliException e) {
80585       {
80586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80587       };
80588     } catch (...) {
80589       {
80590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80591       };
80592     }
80593   }
80594
80595   jresult = (void *)result;
80596   return jresult;
80597 }
80598
80599
80600 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80601   void * jresult ;
80602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80603   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80604
80605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80606   {
80607     try {
80608       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80609     } catch (std::out_of_range& e) {
80610       {
80611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80612       };
80613     } catch (std::exception& e) {
80614       {
80615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80616       };
80617     } catch (Dali::DaliException e) {
80618       {
80619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80620       };
80621     } catch (...) {
80622       {
80623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80624       };
80625     }
80626   }
80627
80628   jresult = (void *)result;
80629   return jresult;
80630 }
80631
80632
80633 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80634   void * jresult ;
80635   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80636   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80637
80638   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80639   {
80640     try {
80641       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80642     } catch (std::out_of_range& e) {
80643       {
80644         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80645       };
80646     } catch (std::exception& e) {
80647       {
80648         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80649       };
80650     } catch (Dali::DaliException e) {
80651       {
80652         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80653       };
80654     } catch (...) {
80655       {
80656         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80657       };
80658     }
80659   }
80660
80661   jresult = (void *)result;
80662   return jresult;
80663 }
80664
80665
80666 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80667   void * jresult ;
80668   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80669   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80670
80671   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80672   {
80673     try {
80674       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80675     } catch (std::out_of_range& e) {
80676       {
80677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80678       };
80679     } catch (std::exception& e) {
80680       {
80681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80682       };
80683     } catch (Dali::DaliException e) {
80684       {
80685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80686       };
80687     } catch (...) {
80688       {
80689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80690       };
80691     }
80692   }
80693
80694   jresult = (void *)result;
80695   return jresult;
80696 }
80697
80698
80699 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80700   void * jresult ;
80701   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80702   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80703
80704   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80705   {
80706     try {
80707       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80708     } catch (std::out_of_range& e) {
80709       {
80710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80711       };
80712     } catch (std::exception& e) {
80713       {
80714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80715       };
80716     } catch (Dali::DaliException e) {
80717       {
80718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80719       };
80720     } catch (...) {
80721       {
80722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80723       };
80724     }
80725   }
80726
80727   jresult = (void *)result;
80728   return jresult;
80729 }
80730
80731
80732 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80733   void * jresult ;
80734   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80735   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80736
80737   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80738   {
80739     try {
80740       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80741     } catch (std::out_of_range& e) {
80742       {
80743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80744       };
80745     } catch (std::exception& e) {
80746       {
80747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80748       };
80749     } catch (Dali::DaliException e) {
80750       {
80751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80752       };
80753     } catch (...) {
80754       {
80755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80756       };
80757     }
80758   }
80759
80760   jresult = (void *)result;
80761   return jresult;
80762 }
80763
80764
80765 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80766   void * jresult ;
80767   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80768   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80769
80770   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80771   {
80772     try {
80773       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80774     } catch (std::out_of_range& e) {
80775       {
80776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80777       };
80778     } catch (std::exception& e) {
80779       {
80780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80781       };
80782     } catch (Dali::DaliException e) {
80783       {
80784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80785       };
80786     } catch (...) {
80787       {
80788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80789       };
80790     }
80791   }
80792
80793   jresult = (void *)result;
80794   return jresult;
80795 }
80796
80797
80798 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80799   void * jresult ;
80800   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80801   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80802
80803   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80804   {
80805     try {
80806       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80807     } catch (std::out_of_range& e) {
80808       {
80809         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80810       };
80811     } catch (std::exception& e) {
80812       {
80813         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80814       };
80815     } catch (Dali::DaliException e) {
80816       {
80817         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80818       };
80819     } catch (...) {
80820       {
80821         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80822       };
80823     }
80824   }
80825
80826   jresult = (void *)result;
80827   return jresult;
80828 }
80829
80830
80831 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80832   void * jresult ;
80833   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80834   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80835
80836   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80837   {
80838     try {
80839       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80840     } catch (std::out_of_range& e) {
80841       {
80842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80843       };
80844     } catch (std::exception& e) {
80845       {
80846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80847       };
80848     } catch (Dali::DaliException e) {
80849       {
80850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80851       };
80852     } catch (...) {
80853       {
80854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80855       };
80856     }
80857   }
80858
80859   jresult = (void *)result;
80860   return jresult;
80861 }
80862
80863
80864 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80865   void * jresult ;
80866   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80867   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80868
80869   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80870   {
80871     try {
80872       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80873     } catch (std::out_of_range& e) {
80874       {
80875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80876       };
80877     } catch (std::exception& e) {
80878       {
80879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80880       };
80881     } catch (Dali::DaliException e) {
80882       {
80883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80884       };
80885     } catch (...) {
80886       {
80887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80888       };
80889     }
80890   }
80891
80892   jresult = (void *)result;
80893   return jresult;
80894 }
80895
80896
80897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80898   void * jresult ;
80899   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80900   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80901
80902   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80903   {
80904     try {
80905       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80906     } catch (std::out_of_range& e) {
80907       {
80908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80909       };
80910     } catch (std::exception& e) {
80911       {
80912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80913       };
80914     } catch (Dali::DaliException e) {
80915       {
80916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80917       };
80918     } catch (...) {
80919       {
80920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80921       };
80922     }
80923   }
80924
80925   jresult = (void *)result;
80926   return jresult;
80927 }
80928
80929
80930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80931   void * jresult ;
80932   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80933   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80934
80935   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80936   {
80937     try {
80938       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80939     } catch (std::out_of_range& e) {
80940       {
80941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80942       };
80943     } catch (std::exception& e) {
80944       {
80945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80946       };
80947     } catch (Dali::DaliException e) {
80948       {
80949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80950       };
80951     } catch (...) {
80952       {
80953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80954       };
80955     }
80956   }
80957
80958   jresult = (void *)result;
80959   return jresult;
80960 }
80961
80962
80963 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80964   void * jresult ;
80965   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80966   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80967
80968   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80969   {
80970     try {
80971       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80972     } catch (std::out_of_range& e) {
80973       {
80974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80975       };
80976     } catch (std::exception& e) {
80977       {
80978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80979       };
80980     } catch (Dali::DaliException e) {
80981       {
80982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80983       };
80984     } catch (...) {
80985       {
80986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80987       };
80988     }
80989   }
80990
80991   jresult = (void *)result;
80992   return jresult;
80993 }
80994
80995
80996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80997   void * jresult ;
80998   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80999   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81000
81001   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81002   {
81003     try {
81004       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
81005     } catch (std::out_of_range& e) {
81006       {
81007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81008       };
81009     } catch (std::exception& e) {
81010       {
81011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81012       };
81013     } catch (Dali::DaliException e) {
81014       {
81015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81016       };
81017     } catch (...) {
81018       {
81019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81020       };
81021     }
81022   }
81023
81024   jresult = (void *)result;
81025   return jresult;
81026 }
81027
81028
81029 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
81030   void * jresult ;
81031   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81032   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81033
81034   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81035   {
81036     try {
81037       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
81038     } catch (std::out_of_range& e) {
81039       {
81040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81041       };
81042     } catch (std::exception& e) {
81043       {
81044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81045       };
81046     } catch (Dali::DaliException e) {
81047       {
81048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81049       };
81050     } catch (...) {
81051       {
81052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81053       };
81054     }
81055   }
81056
81057   jresult = (void *)result;
81058   return jresult;
81059 }
81060
81061
81062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
81063   void * jresult ;
81064   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81065   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81066
81067   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81068   {
81069     try {
81070       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
81071     } catch (std::out_of_range& e) {
81072       {
81073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81074       };
81075     } catch (std::exception& e) {
81076       {
81077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81078       };
81079     } catch (Dali::DaliException e) {
81080       {
81081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81082       };
81083     } catch (...) {
81084       {
81085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81086       };
81087     }
81088   }
81089
81090   jresult = (void *)result;
81091   return jresult;
81092 }
81093
81094
81095 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
81096   void * jresult ;
81097   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81098   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81099
81100   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81101   {
81102     try {
81103       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
81104     } catch (std::out_of_range& e) {
81105       {
81106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81107       };
81108     } catch (std::exception& e) {
81109       {
81110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81111       };
81112     } catch (Dali::DaliException e) {
81113       {
81114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81115       };
81116     } catch (...) {
81117       {
81118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81119       };
81120     }
81121   }
81122
81123   jresult = (void *)result;
81124   return jresult;
81125 }
81126
81127
81128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
81129   void * jresult ;
81130   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81131   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81132
81133   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81134   {
81135     try {
81136       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
81137     } catch (std::out_of_range& e) {
81138       {
81139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81140       };
81141     } catch (std::exception& e) {
81142       {
81143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81144       };
81145     } catch (Dali::DaliException e) {
81146       {
81147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81148       };
81149     } catch (...) {
81150       {
81151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81152       };
81153     }
81154   }
81155
81156   jresult = (void *)result;
81157   return jresult;
81158 }
81159
81160
81161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
81162   void * jresult ;
81163   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81164   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81165
81166   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81167   {
81168     try {
81169       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
81170     } catch (std::out_of_range& e) {
81171       {
81172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81173       };
81174     } catch (std::exception& e) {
81175       {
81176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81177       };
81178     } catch (Dali::DaliException e) {
81179       {
81180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81181       };
81182     } catch (...) {
81183       {
81184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81185       };
81186     }
81187   }
81188
81189   jresult = (void *)result;
81190   return jresult;
81191 }
81192
81193
81194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
81195   void * jresult ;
81196   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81197   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81198
81199   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81200   {
81201     try {
81202       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
81203     } catch (std::out_of_range& e) {
81204       {
81205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81206       };
81207     } catch (std::exception& e) {
81208       {
81209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81210       };
81211     } catch (Dali::DaliException e) {
81212       {
81213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81214       };
81215     } catch (...) {
81216       {
81217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81218       };
81219     }
81220   }
81221
81222   jresult = (void *)result;
81223   return jresult;
81224 }
81225
81226
81227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
81228   void * jresult ;
81229   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81230   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81231
81232   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81233   {
81234     try {
81235       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
81236     } catch (std::out_of_range& e) {
81237       {
81238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81239       };
81240     } catch (std::exception& e) {
81241       {
81242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81243       };
81244     } catch (Dali::DaliException e) {
81245       {
81246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81247       };
81248     } catch (...) {
81249       {
81250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81251       };
81252     }
81253   }
81254
81255   jresult = (void *)result;
81256   return jresult;
81257 }
81258
81259
81260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
81261   void * jresult ;
81262   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81263   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
81264
81265   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81266   {
81267     try {
81268       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
81269     } catch (std::out_of_range& e) {
81270       {
81271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81272       };
81273     } catch (std::exception& e) {
81274       {
81275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81276       };
81277     } catch (Dali::DaliException e) {
81278       {
81279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81280       };
81281     } catch (...) {
81282       {
81283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81284       };
81285     }
81286   }
81287
81288   jresult = (void *)result;
81289   return jresult;
81290 }
81291
81292
81293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
81294   void * jresult ;
81295   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
81296   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
81297
81298   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
81299   {
81300     try {
81301       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
81302     } catch (std::out_of_range& e) {
81303       {
81304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81305       };
81306     } catch (std::exception& e) {
81307       {
81308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81309       };
81310     } catch (Dali::DaliException e) {
81311       {
81312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81313       };
81314     } catch (...) {
81315       {
81316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81317       };
81318     }
81319   }
81320
81321   jresult = (void *)result;
81322   return jresult;
81323 }
81324
81325
81326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
81327   void * jresult ;
81328   Dali::Toolkit::StyleManager *result = 0 ;
81329
81330   {
81331     try {
81332       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
81333     } catch (std::out_of_range& e) {
81334       {
81335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81336       };
81337     } catch (std::exception& e) {
81338       {
81339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81340       };
81341     } catch (Dali::DaliException e) {
81342       {
81343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81344       };
81345     } catch (...) {
81346       {
81347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81348       };
81349     }
81350   }
81351
81352   jresult = (void *)result;
81353   return jresult;
81354 }
81355
81356
81357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
81358   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81359
81360   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81361   {
81362     try {
81363       delete arg1;
81364     } catch (std::out_of_range& e) {
81365       {
81366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81367       };
81368     } catch (std::exception& e) {
81369       {
81370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81371       };
81372     } catch (Dali::DaliException e) {
81373       {
81374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81375       };
81376     } catch (...) {
81377       {
81378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81379       };
81380     }
81381   }
81382
81383 }
81384
81385
81386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
81387   void * jresult ;
81388   Dali::Toolkit::StyleManager result;
81389
81390   {
81391     try {
81392       result = Dali::Toolkit::StyleManager::Get();
81393     } catch (std::out_of_range& e) {
81394       {
81395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81396       };
81397     } catch (std::exception& e) {
81398       {
81399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81400       };
81401     } catch (Dali::DaliException e) {
81402       {
81403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81404       };
81405     } catch (...) {
81406       {
81407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81408       };
81409     }
81410   }
81411
81412   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
81413   return jresult;
81414 }
81415
81416
81417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
81418   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81419   std::string *arg2 = 0 ;
81420
81421   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81422   if (!jarg2) {
81423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81424     return ;
81425   }
81426   std::string arg2_str(jarg2);
81427   arg2 = &arg2_str;
81428   {
81429     try {
81430       (arg1)->ApplyTheme((std::string const &)*arg2);
81431     } catch (std::out_of_range& e) {
81432       {
81433         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81434       };
81435     } catch (std::exception& e) {
81436       {
81437         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81438       };
81439     } catch (Dali::DaliException e) {
81440       {
81441         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81442       };
81443     } catch (...) {
81444       {
81445         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81446       };
81447     }
81448   }
81449
81450
81451   //argout typemap for const std::string&
81452
81453 }
81454
81455
81456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
81457   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81458
81459   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81460   {
81461     try {
81462       (arg1)->ApplyDefaultTheme();
81463     } catch (std::out_of_range& e) {
81464       {
81465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81466       };
81467     } catch (std::exception& e) {
81468       {
81469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81470       };
81471     } catch (Dali::DaliException e) {
81472       {
81473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81474       };
81475     } catch (...) {
81476       {
81477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81478       };
81479     }
81480   }
81481
81482 }
81483
81484
81485 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81486   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81487   std::string *arg2 = 0 ;
81488   Dali::Property::Value *arg3 = 0 ;
81489
81490   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81491   if (!jarg2) {
81492     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81493     return ;
81494   }
81495   std::string arg2_str(jarg2);
81496   arg2 = &arg2_str;
81497   arg3 = (Dali::Property::Value *)jarg3;
81498   if (!arg3) {
81499     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81500     return ;
81501   }
81502   {
81503     try {
81504       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81505     } catch (std::out_of_range& e) {
81506       {
81507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81508       };
81509     } catch (std::exception& e) {
81510       {
81511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81512       };
81513     } catch (Dali::DaliException e) {
81514       {
81515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81516       };
81517     } catch (...) {
81518       {
81519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81520       };
81521     }
81522   }
81523
81524
81525   //argout typemap for const std::string&
81526
81527 }
81528
81529
81530 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81531   unsigned int jresult ;
81532   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81533   std::string *arg2 = 0 ;
81534   Dali::Property::Value *arg3 = 0 ;
81535   bool result;
81536
81537   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81538   if (!jarg2) {
81539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81540     return 0;
81541   }
81542   std::string arg2_str(jarg2);
81543   arg2 = &arg2_str;
81544   arg3 = (Dali::Property::Value *)jarg3;
81545   if (!arg3) {
81546     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81547     return 0;
81548   }
81549   {
81550     try {
81551       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81552     } catch (std::out_of_range& e) {
81553       {
81554         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81555       };
81556     } catch (std::exception& e) {
81557       {
81558         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81559       };
81560     } catch (Dali::DaliException e) {
81561       {
81562         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81563       };
81564     } catch (...) {
81565       {
81566         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81567       };
81568     }
81569   }
81570
81571   jresult = result;
81572
81573   //argout typemap for const std::string&
81574
81575   return jresult;
81576 }
81577
81578
81579 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81580   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81581   Dali::Toolkit::Control arg2 ;
81582   std::string *arg3 = 0 ;
81583   std::string *arg4 = 0 ;
81584   Dali::Toolkit::Control *argp2 ;
81585
81586   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81587   argp2 = (Dali::Toolkit::Control *)jarg2;
81588   if (!argp2) {
81589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81590     return ;
81591   }
81592   arg2 = *argp2;
81593   if (!jarg3) {
81594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81595     return ;
81596   }
81597   std::string arg3_str(jarg3);
81598   arg3 = &arg3_str;
81599   if (!jarg4) {
81600     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81601     return ;
81602   }
81603   std::string arg4_str(jarg4);
81604   arg4 = &arg4_str;
81605   {
81606     try {
81607       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81608     } catch (std::out_of_range& e) {
81609       {
81610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81611       };
81612     } catch (std::exception& e) {
81613       {
81614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81615       };
81616     } catch (Dali::DaliException e) {
81617       {
81618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81619       };
81620     } catch (...) {
81621       {
81622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81623       };
81624     }
81625   }
81626
81627
81628   //argout typemap for const std::string&
81629
81630
81631   //argout typemap for const std::string&
81632
81633 }
81634
81635
81636 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81637   void * jresult ;
81638   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81639   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81640
81641   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81642   {
81643     try {
81644       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81645     } catch (std::out_of_range& e) {
81646       {
81647         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81648       };
81649     } catch (std::exception& e) {
81650       {
81651         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81652       };
81653     } catch (Dali::DaliException e) {
81654       {
81655         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81656       };
81657     } catch (...) {
81658       {
81659         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81660       };
81661     }
81662   }
81663
81664   jresult = (void *)result;
81665   return jresult;
81666 }
81667
81668
81669 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81670   int jresult ;
81671   int result;
81672
81673   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81674   jresult = (int)result;
81675   return jresult;
81676 }
81677
81678
81679 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81680   int jresult ;
81681   int result;
81682
81683   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81684   jresult = (int)result;
81685   return jresult;
81686 }
81687
81688
81689 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81690   int jresult ;
81691   int result;
81692
81693   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81694   jresult = (int)result;
81695   return jresult;
81696 }
81697
81698
81699 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81700   int jresult ;
81701   int result;
81702
81703   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81704   jresult = (int)result;
81705   return jresult;
81706 }
81707
81708
81709 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81710   int jresult ;
81711   int result;
81712
81713   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81714   jresult = (int)result;
81715   return jresult;
81716 }
81717
81718
81719 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81720   int jresult ;
81721   int result;
81722
81723   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81724   jresult = (int)result;
81725   return jresult;
81726 }
81727
81728
81729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81730   int jresult ;
81731   int result;
81732
81733   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81734   jresult = (int)result;
81735   return jresult;
81736 }
81737
81738
81739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81740   int jresult ;
81741   int result;
81742
81743   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81744   jresult = (int)result;
81745   return jresult;
81746 }
81747
81748
81749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81750   int jresult ;
81751   int result;
81752
81753   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81754   jresult = (int)result;
81755   return jresult;
81756 }
81757
81758
81759 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81760   int jresult ;
81761   int result;
81762
81763   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81764   jresult = (int)result;
81765   return jresult;
81766 }
81767
81768
81769 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81770   int jresult ;
81771   int result;
81772
81773   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81774   jresult = (int)result;
81775   return jresult;
81776 }
81777
81778
81779 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81780   int jresult ;
81781   int result;
81782
81783   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81784   jresult = (int)result;
81785   return jresult;
81786 }
81787
81788
81789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81790   int jresult ;
81791   int result;
81792
81793   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81794   jresult = (int)result;
81795   return jresult;
81796 }
81797
81798
81799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81800   int jresult ;
81801   int result;
81802
81803   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81804   jresult = (int)result;
81805   return jresult;
81806 }
81807
81808
81809 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81810   int jresult ;
81811   int result;
81812
81813   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81814   jresult = (int)result;
81815   return jresult;
81816 }
81817
81818
81819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81820   void * jresult ;
81821   Dali::Toolkit::Slider::Property *result = 0 ;
81822
81823   {
81824     try {
81825       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81826     } catch (std::out_of_range& e) {
81827       {
81828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81829       };
81830     } catch (std::exception& e) {
81831       {
81832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81833       };
81834     } catch (Dali::DaliException e) {
81835       {
81836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81837       };
81838     } catch (...) {
81839       {
81840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81841       };
81842     }
81843   }
81844
81845   jresult = (void *)result;
81846   return jresult;
81847 }
81848
81849
81850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81851   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81852
81853   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81854   {
81855     try {
81856       delete arg1;
81857     } catch (std::out_of_range& e) {
81858       {
81859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81860       };
81861     } catch (std::exception& e) {
81862       {
81863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81864       };
81865     } catch (Dali::DaliException e) {
81866       {
81867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81868       };
81869     } catch (...) {
81870       {
81871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81872       };
81873     }
81874   }
81875
81876 }
81877
81878
81879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81880   void * jresult ;
81881   Dali::Toolkit::Slider result;
81882
81883   {
81884     try {
81885       result = Dali::Toolkit::Slider::New();
81886     } catch (std::out_of_range& e) {
81887       {
81888         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81889       };
81890     } catch (std::exception& e) {
81891       {
81892         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81893       };
81894     } catch (Dali::DaliException e) {
81895       {
81896         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81897       };
81898     } catch (...) {
81899       {
81900         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81901       };
81902     }
81903   }
81904
81905   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81906   return jresult;
81907 }
81908
81909
81910 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81911   void * jresult ;
81912   Dali::Toolkit::Slider *result = 0 ;
81913
81914   {
81915     try {
81916       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81917     } catch (std::out_of_range& e) {
81918       {
81919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81920       };
81921     } catch (std::exception& e) {
81922       {
81923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81924       };
81925     } catch (Dali::DaliException e) {
81926       {
81927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81928       };
81929     } catch (...) {
81930       {
81931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81932       };
81933     }
81934   }
81935
81936   jresult = (void *)result;
81937   return jresult;
81938 }
81939
81940
81941 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81942   void * jresult ;
81943   Dali::Toolkit::Slider *arg1 = 0 ;
81944   Dali::Toolkit::Slider *result = 0 ;
81945
81946   arg1 = (Dali::Toolkit::Slider *)jarg1;
81947   if (!arg1) {
81948     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81949     return 0;
81950   }
81951   {
81952     try {
81953       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81954     } catch (std::out_of_range& e) {
81955       {
81956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81957       };
81958     } catch (std::exception& e) {
81959       {
81960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81961       };
81962     } catch (Dali::DaliException e) {
81963       {
81964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81965       };
81966     } catch (...) {
81967       {
81968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81969       };
81970     }
81971   }
81972
81973   jresult = (void *)result;
81974   return jresult;
81975 }
81976
81977
81978 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81979   void * jresult ;
81980   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81981   Dali::Toolkit::Slider *arg2 = 0 ;
81982   Dali::Toolkit::Slider *result = 0 ;
81983
81984   arg1 = (Dali::Toolkit::Slider *)jarg1;
81985   arg2 = (Dali::Toolkit::Slider *)jarg2;
81986   if (!arg2) {
81987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81988     return 0;
81989   }
81990   {
81991     try {
81992       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81993     } catch (std::out_of_range& e) {
81994       {
81995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81996       };
81997     } catch (std::exception& e) {
81998       {
81999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82000       };
82001     } catch (Dali::DaliException e) {
82002       {
82003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82004       };
82005     } catch (...) {
82006       {
82007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82008       };
82009     }
82010   }
82011
82012   jresult = (void *)result;
82013   return jresult;
82014 }
82015
82016
82017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
82018   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82019
82020   arg1 = (Dali::Toolkit::Slider *)jarg1;
82021   {
82022     try {
82023       delete arg1;
82024     } catch (std::out_of_range& e) {
82025       {
82026         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82027       };
82028     } catch (std::exception& e) {
82029       {
82030         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82031       };
82032     } catch (Dali::DaliException e) {
82033       {
82034         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82035       };
82036     } catch (...) {
82037       {
82038         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82039       };
82040     }
82041   }
82042
82043 }
82044
82045
82046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
82047   void * jresult ;
82048   Dali::BaseHandle arg1 ;
82049   Dali::BaseHandle *argp1 ;
82050   Dali::Toolkit::Slider result;
82051
82052   argp1 = (Dali::BaseHandle *)jarg1;
82053   if (!argp1) {
82054     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82055     return 0;
82056   }
82057   arg1 = *argp1;
82058   {
82059     try {
82060       result = Dali::Toolkit::Slider::DownCast(arg1);
82061     } catch (std::out_of_range& e) {
82062       {
82063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82064       };
82065     } catch (std::exception& e) {
82066       {
82067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82068       };
82069     } catch (Dali::DaliException e) {
82070       {
82071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82072       };
82073     } catch (...) {
82074       {
82075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82076       };
82077     }
82078   }
82079
82080   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
82081   return jresult;
82082 }
82083
82084
82085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
82086   void * jresult ;
82087   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82088   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82089
82090   arg1 = (Dali::Toolkit::Slider *)jarg1;
82091   {
82092     try {
82093       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
82094     } catch (std::out_of_range& e) {
82095       {
82096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82097       };
82098     } catch (std::exception& e) {
82099       {
82100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82101       };
82102     } catch (Dali::DaliException e) {
82103       {
82104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82105       };
82106     } catch (...) {
82107       {
82108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82109       };
82110     }
82111   }
82112
82113   jresult = (void *)result;
82114   return jresult;
82115 }
82116
82117
82118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
82119   void * jresult ;
82120   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82121   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
82122
82123   arg1 = (Dali::Toolkit::Slider *)jarg1;
82124   {
82125     try {
82126       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
82127     } catch (std::out_of_range& e) {
82128       {
82129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82130       };
82131     } catch (std::exception& e) {
82132       {
82133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82134       };
82135     } catch (Dali::DaliException e) {
82136       {
82137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82138       };
82139     } catch (...) {
82140       {
82141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82142       };
82143     }
82144   }
82145
82146   jresult = (void *)result;
82147   return jresult;
82148 }
82149
82150
82151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
82152   void * jresult ;
82153   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
82154   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
82155
82156   arg1 = (Dali::Toolkit::Slider *)jarg1;
82157   {
82158     try {
82159       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
82160     } catch (std::out_of_range& e) {
82161       {
82162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82163       };
82164     } catch (std::exception& e) {
82165       {
82166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82167       };
82168     } catch (Dali::DaliException e) {
82169       {
82170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82171       };
82172     } catch (...) {
82173       {
82174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82175       };
82176     }
82177   }
82178
82179   jresult = (void *)result;
82180   return jresult;
82181 }
82182
82183
82184 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
82185   int jresult ;
82186   int result;
82187
82188   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
82189   jresult = (int)result;
82190   return jresult;
82191 }
82192
82193
82194 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
82195   int jresult ;
82196   int result;
82197
82198   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
82199   jresult = (int)result;
82200   return jresult;
82201 }
82202
82203
82204 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
82205   int jresult ;
82206   int result;
82207
82208   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
82209   jresult = (int)result;
82210   return jresult;
82211 }
82212
82213
82214 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
82215   int jresult ;
82216   int result;
82217
82218   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
82219   jresult = (int)result;
82220   return jresult;
82221 }
82222
82223
82224 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
82225   int result;
82226
82227   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
82228
82229   return result;
82230 }
82231
82232
82233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
82234   void * jresult ;
82235   Dali::Toolkit::VideoView::Property *result = 0 ;
82236
82237   {
82238     try {
82239       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
82240     } catch (std::out_of_range& e) {
82241       {
82242         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82243       };
82244     } catch (std::exception& e) {
82245       {
82246         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82247       };
82248     } catch (Dali::DaliException e) {
82249       {
82250         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82251       };
82252     } catch (...) {
82253       {
82254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82255       };
82256     }
82257   }
82258
82259   jresult = (void *)result;
82260   return jresult;
82261 }
82262
82263
82264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
82265   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
82266
82267   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
82268   {
82269     try {
82270       delete arg1;
82271     } catch (std::out_of_range& e) {
82272       {
82273         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82274       };
82275     } catch (std::exception& e) {
82276       {
82277         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82278       };
82279     } catch (Dali::DaliException e) {
82280       {
82281         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82282       };
82283     } catch (...) {
82284       {
82285         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82286       };
82287     }
82288   }
82289
82290 }
82291
82292
82293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
82294   void * jresult ;
82295   Dali::Toolkit::VideoView result;
82296
82297   {
82298     try {
82299       result = Dali::Toolkit::VideoView::New();
82300     } catch (std::out_of_range& e) {
82301       {
82302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82303       };
82304     } catch (std::exception& e) {
82305       {
82306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82307       };
82308     } catch (Dali::DaliException e) {
82309       {
82310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82311       };
82312     } catch (...) {
82313       {
82314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82315       };
82316     }
82317   }
82318
82319   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82320   return jresult;
82321 }
82322
82323
82324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
82325   void * jresult ;
82326   std::string *arg1 = 0 ;
82327   Dali::Toolkit::VideoView result;
82328
82329   if (!jarg1) {
82330     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82331     return 0;
82332   }
82333   std::string arg1_str(jarg1);
82334   arg1 = &arg1_str;
82335   {
82336     try {
82337       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
82338     } catch (std::out_of_range& e) {
82339       {
82340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82341       };
82342     } catch (std::exception& e) {
82343       {
82344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82345       };
82346     } catch (Dali::DaliException e) {
82347       {
82348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82349       };
82350     } catch (...) {
82351       {
82352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82353       };
82354     }
82355   }
82356
82357   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82358
82359   //argout typemap for const std::string&
82360
82361   return jresult;
82362 }
82363
82364
82365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
82366   void * jresult ;
82367   Dali::Toolkit::VideoView result;
82368   {
82369     try {
82370       result = Dali::Toolkit::VideoView::New(swCodec);
82371     } catch (std::out_of_range& e) {
82372       {
82373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82374       };
82375     } catch (std::exception& e) {
82376       {
82377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82378       };
82379     } catch (Dali::DaliException e) {
82380       {
82381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82382       };
82383     } catch (...) {
82384       {
82385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82386       };
82387     }
82388   }
82389
82390   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82391
82392   //argout typemap for const std::string&
82393
82394   return jresult;
82395 }
82396
82397
82398 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
82399   void * jresult ;
82400   std::string *arg1 = 0 ;
82401   Dali::Toolkit::VideoView result;
82402
82403   if (!jarg1) {
82404     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
82405     return 0;
82406   }
82407   std::string arg1_str(jarg1);
82408   arg1 = &arg1_str;
82409   {
82410     try {
82411       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
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 = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82432
82433   //argout typemap for const std::string&
82434
82435   return jresult;
82436 }
82437
82438
82439 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
82440   void * jresult ;
82441   Dali::Toolkit::VideoView *result = 0 ;
82442
82443   {
82444     try {
82445       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
82446     } catch (std::out_of_range& e) {
82447       {
82448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82449       };
82450     } catch (std::exception& e) {
82451       {
82452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82453       };
82454     } catch (Dali::DaliException e) {
82455       {
82456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82457       };
82458     } catch (...) {
82459       {
82460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82461       };
82462     }
82463   }
82464
82465   jresult = (void *)result;
82466   return jresult;
82467 }
82468
82469
82470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
82471   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82472
82473   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82474   {
82475     try {
82476       delete arg1;
82477     } catch (std::out_of_range& e) {
82478       {
82479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82480       };
82481     } catch (std::exception& e) {
82482       {
82483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82484       };
82485     } catch (Dali::DaliException e) {
82486       {
82487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82488       };
82489     } catch (...) {
82490       {
82491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82492       };
82493     }
82494   }
82495
82496 }
82497
82498
82499 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82500   void * jresult ;
82501   Dali::Toolkit::VideoView *arg1 = 0 ;
82502   Dali::Toolkit::VideoView *result = 0 ;
82503
82504   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82505   if (!arg1) {
82506     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82507     return 0;
82508   }
82509   {
82510     try {
82511       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82512     } catch (std::out_of_range& e) {
82513       {
82514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82515       };
82516     } catch (std::exception& e) {
82517       {
82518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82519       };
82520     } catch (Dali::DaliException e) {
82521       {
82522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82523       };
82524     } catch (...) {
82525       {
82526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82527       };
82528     }
82529   }
82530
82531   jresult = (void *)result;
82532   return jresult;
82533 }
82534
82535
82536 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82537   void * jresult ;
82538   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82539   Dali::Toolkit::VideoView *arg2 = 0 ;
82540   Dali::Toolkit::VideoView *result = 0 ;
82541
82542   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82543   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82544   if (!arg2) {
82545     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82546     return 0;
82547   }
82548   {
82549     try {
82550       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82551     } catch (std::out_of_range& e) {
82552       {
82553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82554       };
82555     } catch (std::exception& e) {
82556       {
82557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82558       };
82559     } catch (Dali::DaliException e) {
82560       {
82561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82562       };
82563     } catch (...) {
82564       {
82565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82566       };
82567     }
82568   }
82569
82570   jresult = (void *)result;
82571   return jresult;
82572 }
82573
82574
82575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82576   void * jresult ;
82577   Dali::BaseHandle arg1 ;
82578   Dali::BaseHandle *argp1 ;
82579   Dali::Toolkit::VideoView result;
82580
82581   argp1 = (Dali::BaseHandle *)jarg1;
82582   if (!argp1) {
82583     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82584     return 0;
82585   }
82586   arg1 = *argp1;
82587   {
82588     try {
82589       result = Dali::Toolkit::VideoView::DownCast(arg1);
82590     } catch (std::out_of_range& e) {
82591       {
82592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82593       };
82594     } catch (std::exception& e) {
82595       {
82596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82597       };
82598     } catch (Dali::DaliException e) {
82599       {
82600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82601       };
82602     } catch (...) {
82603       {
82604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82605       };
82606     }
82607   }
82608
82609   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82610   return jresult;
82611 }
82612
82613
82614 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82615   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82616
82617   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82618   {
82619     try {
82620       (arg1)->Play();
82621     } catch (std::out_of_range& e) {
82622       {
82623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82624       };
82625     } catch (std::exception& e) {
82626       {
82627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82628       };
82629     } catch (Dali::DaliException e) {
82630       {
82631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82632       };
82633     } catch (...) {
82634       {
82635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82636       };
82637     }
82638   }
82639
82640 }
82641
82642
82643 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82644   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82645
82646   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82647   {
82648     try {
82649       (arg1)->Pause();
82650     } catch (std::out_of_range& e) {
82651       {
82652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82653       };
82654     } catch (std::exception& e) {
82655       {
82656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82657       };
82658     } catch (Dali::DaliException e) {
82659       {
82660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82661       };
82662     } catch (...) {
82663       {
82664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82665       };
82666     }
82667   }
82668
82669 }
82670
82671
82672 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82673   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82674
82675   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82676   {
82677     try {
82678       (arg1)->Stop();
82679     } catch (std::out_of_range& e) {
82680       {
82681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82682       };
82683     } catch (std::exception& e) {
82684       {
82685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82686       };
82687     } catch (Dali::DaliException e) {
82688       {
82689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82690       };
82691     } catch (...) {
82692       {
82693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82694       };
82695     }
82696   }
82697
82698 }
82699
82700
82701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82702   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82703   int arg2 ;
82704
82705   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82706   arg2 = (int)jarg2;
82707   {
82708     try {
82709       (arg1)->Forward(arg2);
82710     } catch (std::out_of_range& e) {
82711       {
82712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82713       };
82714     } catch (std::exception& e) {
82715       {
82716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82717       };
82718     } catch (Dali::DaliException e) {
82719       {
82720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82721       };
82722     } catch (...) {
82723       {
82724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82725       };
82726     }
82727   }
82728
82729 }
82730
82731
82732 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82733   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82734   int arg2 ;
82735
82736   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82737   arg2 = (int)jarg2;
82738   {
82739     try {
82740       (arg1)->Backward(arg2);
82741     } catch (std::out_of_range& e) {
82742       {
82743         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82744       };
82745     } catch (std::exception& e) {
82746       {
82747         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82748       };
82749     } catch (Dali::DaliException e) {
82750       {
82751         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82752       };
82753     } catch (...) {
82754       {
82755         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82756       };
82757     }
82758   }
82759
82760 }
82761
82762
82763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82764   void * jresult ;
82765   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82766   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82767
82768   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82769   {
82770     try {
82771       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82772     } catch (std::out_of_range& e) {
82773       {
82774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82775       };
82776     } catch (std::exception& e) {
82777       {
82778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82779       };
82780     } catch (Dali::DaliException e) {
82781       {
82782         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82783       };
82784     } catch (...) {
82785       {
82786         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82787       };
82788     }
82789   }
82790
82791   jresult = (void *)result;
82792   return jresult;
82793 }
82794
82795 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82796 {
82797   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82798   if( arg1 == nullptr )
82799   {
82800     DALI_LOG_ERROR("VideoView is nullptr!");
82801     return nullptr;
82802   }
82803   void * ret = nullptr;
82804   {
82805     try{
82806
82807       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82808       ret = Dali::AnyCast< void * >( result );
82809
82810     } catch (std::out_of_range& e) {
82811       {
82812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82813       };
82814     } catch (std::exception& e) {
82815       {
82816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82817       };
82818     } catch (Dali::DaliException e) {
82819       {
82820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82821       };
82822     } catch (...) {
82823       {
82824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82825       };
82826     }
82827   }
82828   return ret;
82829 }
82830
82831
82832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82833   int jresult ;
82834   int result;
82835
82836   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82837   jresult = (int)result;
82838   return jresult;
82839 }
82840
82841
82842 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82843   int jresult ;
82844   int result;
82845
82846   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82847   jresult = (int)result;
82848   return jresult;
82849 }
82850
82851
82852 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82853   int jresult ;
82854   int result;
82855
82856   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82857   jresult = (int)result;
82858   return jresult;
82859 }
82860
82861
82862 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82863   int jresult ;
82864   int result;
82865
82866   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82867   jresult = (int)result;
82868   return jresult;
82869 }
82870
82871
82872 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82873   int jresult ;
82874   int result;
82875
82876   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82877   jresult = (int)result;
82878   return jresult;
82879 }
82880
82881
82882 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82883   int jresult ;
82884   int result;
82885
82886   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82887   jresult = (int)result;
82888   return jresult;
82889 }
82890
82891
82892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82893   int jresult ;
82894   int result;
82895
82896   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82897   jresult = (int)result;
82898   return jresult;
82899 }
82900
82901
82902 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82903   int jresult ;
82904   int result;
82905
82906   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82907   jresult = (int)result;
82908   return jresult;
82909 }
82910
82911
82912 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82913   int jresult ;
82914   int result;
82915
82916   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82917   jresult = (int)result;
82918   return jresult;
82919 }
82920
82921
82922 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82923   int jresult ;
82924   int result;
82925
82926   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82927   jresult = (int)result;
82928   return jresult;
82929 }
82930
82931
82932 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82933   int jresult ;
82934   int result;
82935
82936   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82937   jresult = (int)result;
82938   return jresult;
82939 }
82940
82941
82942 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82943   int jresult ;
82944   int result;
82945
82946   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82947   jresult = (int)result;
82948   return jresult;
82949 }
82950
82951
82952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82953   int jresult ;
82954   int result;
82955
82956   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82957   jresult = (int)result;
82958   return jresult;
82959 }
82960
82961
82962 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82963   int jresult ;
82964   int result;
82965
82966   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82967   jresult = (int)result;
82968   return jresult;
82969 }
82970
82971
82972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82973   int jresult ;
82974   int result;
82975
82976   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82977   jresult = (int)result;
82978   return jresult;
82979 }
82980
82981
82982 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82983   int jresult ;
82984   int result;
82985
82986   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82987   jresult = (int)result;
82988   return jresult;
82989 }
82990
82991
82992 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82993   int jresult ;
82994   int result;
82995
82996   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82997   jresult = (int)result;
82998   return jresult;
82999 }
83000
83001
83002 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
83003   int jresult ;
83004   int result;
83005
83006   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
83007   jresult = (int)result;
83008   return jresult;
83009 }
83010
83011
83012 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
83013   int jresult ;
83014   int result;
83015
83016   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
83017   jresult = (int)result;
83018   return jresult;
83019 }
83020
83021
83022 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
83023   int jresult ;
83024   int result;
83025
83026   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
83027   jresult = (int)result;
83028   return jresult;
83029 }
83030
83031
83032 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
83033   int jresult ;
83034   int result;
83035
83036   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
83037   jresult = (int)result;
83038   return jresult;
83039 }
83040
83041
83042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
83043   void * jresult ;
83044   Dali::Toolkit::Popup::Property *result = 0 ;
83045
83046   {
83047     try {
83048       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
83049     } catch (std::out_of_range& e) {
83050       {
83051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83052       };
83053     } catch (std::exception& e) {
83054       {
83055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83056       };
83057     } catch (Dali::DaliException e) {
83058       {
83059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83060       };
83061     } catch (...) {
83062       {
83063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83064       };
83065     }
83066   }
83067
83068   jresult = (void *)result;
83069   return jresult;
83070 }
83071
83072
83073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
83074   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
83075
83076   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
83077   {
83078     try {
83079       delete arg1;
83080     } catch (std::out_of_range& e) {
83081       {
83082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83083       };
83084     } catch (std::exception& e) {
83085       {
83086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83087       };
83088     } catch (Dali::DaliException e) {
83089       {
83090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83091       };
83092     } catch (...) {
83093       {
83094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83095       };
83096     }
83097   }
83098
83099 }
83100
83101
83102 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
83103   void * jresult ;
83104   Dali::Toolkit::Popup *result = 0 ;
83105
83106   {
83107     try {
83108       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
83109     } catch (std::out_of_range& e) {
83110       {
83111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83112       };
83113     } catch (std::exception& e) {
83114       {
83115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83116       };
83117     } catch (Dali::DaliException e) {
83118       {
83119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83120       };
83121     } catch (...) {
83122       {
83123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83124       };
83125     }
83126   }
83127
83128   jresult = (void *)result;
83129   return jresult;
83130 }
83131
83132
83133 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
83134   void * jresult ;
83135   Dali::Toolkit::Popup result;
83136
83137   {
83138     try {
83139       result = Dali::Toolkit::Popup::New();
83140     } catch (std::out_of_range& e) {
83141       {
83142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83143       };
83144     } catch (std::exception& e) {
83145       {
83146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83147       };
83148     } catch (Dali::DaliException e) {
83149       {
83150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83151       };
83152     } catch (...) {
83153       {
83154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83155       };
83156     }
83157   }
83158
83159   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83160   return jresult;
83161 }
83162
83163
83164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
83165   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83166
83167   arg1 = (Dali::Toolkit::Popup *)jarg1;
83168   {
83169     try {
83170       delete arg1;
83171     } catch (std::out_of_range& e) {
83172       {
83173         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83174       };
83175     } catch (std::exception& e) {
83176       {
83177         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83178       };
83179     } catch (Dali::DaliException e) {
83180       {
83181         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83182       };
83183     } catch (...) {
83184       {
83185         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83186       };
83187     }
83188   }
83189
83190 }
83191
83192
83193 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
83194   void * jresult ;
83195   Dali::Toolkit::Popup *arg1 = 0 ;
83196   Dali::Toolkit::Popup *result = 0 ;
83197
83198   arg1 = (Dali::Toolkit::Popup *)jarg1;
83199   if (!arg1) {
83200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83201     return 0;
83202   }
83203   {
83204     try {
83205       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
83206     } catch (std::out_of_range& e) {
83207       {
83208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83209       };
83210     } catch (std::exception& e) {
83211       {
83212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83213       };
83214     } catch (Dali::DaliException e) {
83215       {
83216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83217       };
83218     } catch (...) {
83219       {
83220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83221       };
83222     }
83223   }
83224
83225   jresult = (void *)result;
83226   return jresult;
83227 }
83228
83229
83230 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
83231   void * jresult ;
83232   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83233   Dali::Toolkit::Popup *arg2 = 0 ;
83234   Dali::Toolkit::Popup *result = 0 ;
83235
83236   arg1 = (Dali::Toolkit::Popup *)jarg1;
83237   arg2 = (Dali::Toolkit::Popup *)jarg2;
83238   if (!arg2) {
83239     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
83240     return 0;
83241   }
83242   {
83243     try {
83244       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
83245     } catch (std::out_of_range& e) {
83246       {
83247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83248       };
83249     } catch (std::exception& e) {
83250       {
83251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83252       };
83253     } catch (Dali::DaliException e) {
83254       {
83255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83256       };
83257     } catch (...) {
83258       {
83259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83260       };
83261     }
83262   }
83263
83264   jresult = (void *)result;
83265   return jresult;
83266 }
83267
83268
83269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
83270   void * jresult ;
83271   Dali::BaseHandle arg1 ;
83272   Dali::BaseHandle *argp1 ;
83273   Dali::Toolkit::Popup result;
83274
83275   argp1 = (Dali::BaseHandle *)jarg1;
83276   if (!argp1) {
83277     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83278     return 0;
83279   }
83280   arg1 = *argp1;
83281   {
83282     try {
83283       result = Dali::Toolkit::Popup::DownCast(arg1);
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 = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
83304   return jresult;
83305 }
83306
83307
83308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
83309   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83310   Dali::Actor arg2 ;
83311   Dali::Actor *argp2 ;
83312
83313   arg1 = (Dali::Toolkit::Popup *)jarg1;
83314   argp2 = (Dali::Actor *)jarg2;
83315   if (!argp2) {
83316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83317     return ;
83318   }
83319   arg2 = *argp2;
83320   {
83321     try {
83322       (arg1)->SetTitle(arg2);
83323     } catch (std::out_of_range& e) {
83324       {
83325         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83326       };
83327     } catch (std::exception& e) {
83328       {
83329         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83330       };
83331     } catch (Dali::DaliException e) {
83332       {
83333         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83334       };
83335     } catch (...) {
83336       {
83337         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83338       };
83339     }
83340   }
83341
83342 }
83343
83344
83345 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
83346   void * jresult ;
83347   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83348   Dali::Actor result;
83349
83350   arg1 = (Dali::Toolkit::Popup *)jarg1;
83351   {
83352     try {
83353       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
83354     } catch (std::out_of_range& e) {
83355       {
83356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83357       };
83358     } catch (std::exception& e) {
83359       {
83360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83361       };
83362     } catch (Dali::DaliException e) {
83363       {
83364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83365       };
83366     } catch (...) {
83367       {
83368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83369       };
83370     }
83371   }
83372
83373   jresult = new Dali::Actor((const Dali::Actor &)result);
83374   return jresult;
83375 }
83376
83377
83378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
83379   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83380   Dali::Actor arg2 ;
83381   Dali::Actor *argp2 ;
83382
83383   arg1 = (Dali::Toolkit::Popup *)jarg1;
83384   argp2 = (Dali::Actor *)jarg2;
83385   if (!argp2) {
83386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83387     return ;
83388   }
83389   arg2 = *argp2;
83390   {
83391     try {
83392       (arg1)->SetContent(arg2);
83393     } catch (std::out_of_range& e) {
83394       {
83395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83396       };
83397     } catch (std::exception& e) {
83398       {
83399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83400       };
83401     } catch (Dali::DaliException e) {
83402       {
83403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83404       };
83405     } catch (...) {
83406       {
83407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83408       };
83409     }
83410   }
83411
83412 }
83413
83414
83415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
83416   void * jresult ;
83417   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83418   Dali::Actor result;
83419
83420   arg1 = (Dali::Toolkit::Popup *)jarg1;
83421   {
83422     try {
83423       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
83424     } catch (std::out_of_range& e) {
83425       {
83426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83427       };
83428     } catch (std::exception& e) {
83429       {
83430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83431       };
83432     } catch (Dali::DaliException e) {
83433       {
83434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83435       };
83436     } catch (...) {
83437       {
83438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83439       };
83440     }
83441   }
83442
83443   jresult = new Dali::Actor((const Dali::Actor &)result);
83444   return jresult;
83445 }
83446
83447
83448 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
83449   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83450   Dali::Actor arg2 ;
83451   Dali::Actor *argp2 ;
83452
83453   arg1 = (Dali::Toolkit::Popup *)jarg1;
83454   argp2 = (Dali::Actor *)jarg2;
83455   if (!argp2) {
83456     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83457     return ;
83458   }
83459   arg2 = *argp2;
83460   {
83461     try {
83462       (arg1)->SetFooter(arg2);
83463     } catch (std::out_of_range& e) {
83464       {
83465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83466       };
83467     } catch (std::exception& e) {
83468       {
83469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83470       };
83471     } catch (Dali::DaliException e) {
83472       {
83473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83474       };
83475     } catch (...) {
83476       {
83477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83478       };
83479     }
83480   }
83481
83482 }
83483
83484
83485 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
83486   void * jresult ;
83487   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83488   Dali::Actor result;
83489
83490   arg1 = (Dali::Toolkit::Popup *)jarg1;
83491   {
83492     try {
83493       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
83494     } catch (std::out_of_range& e) {
83495       {
83496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83497       };
83498     } catch (std::exception& e) {
83499       {
83500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83501       };
83502     } catch (Dali::DaliException e) {
83503       {
83504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83505       };
83506     } catch (...) {
83507       {
83508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83509       };
83510     }
83511   }
83512
83513   jresult = new Dali::Actor((const Dali::Actor &)result);
83514   return jresult;
83515 }
83516
83517
83518 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83519   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83520   Dali::Toolkit::Popup::DisplayState arg2 ;
83521
83522   arg1 = (Dali::Toolkit::Popup *)jarg1;
83523   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83524   {
83525     try {
83526       (arg1)->SetDisplayState(arg2);
83527     } catch (std::out_of_range& e) {
83528       {
83529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83530       };
83531     } catch (std::exception& e) {
83532       {
83533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83534       };
83535     } catch (Dali::DaliException e) {
83536       {
83537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83538       };
83539     } catch (...) {
83540       {
83541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83542       };
83543     }
83544   }
83545
83546 }
83547
83548
83549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83550   int jresult ;
83551   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83552   Dali::Toolkit::Popup::DisplayState result;
83553
83554   arg1 = (Dali::Toolkit::Popup *)jarg1;
83555   {
83556     try {
83557       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83558     } catch (std::out_of_range& e) {
83559       {
83560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83561       };
83562     } catch (std::exception& e) {
83563       {
83564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83565       };
83566     } catch (Dali::DaliException e) {
83567       {
83568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83569       };
83570     } catch (...) {
83571       {
83572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83573       };
83574     }
83575   }
83576
83577   jresult = (int)result;
83578   return jresult;
83579 }
83580
83581
83582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83583   void * jresult ;
83584   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83585   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83586
83587   arg1 = (Dali::Toolkit::Popup *)jarg1;
83588   {
83589     try {
83590       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83591     } catch (std::out_of_range& e) {
83592       {
83593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83594       };
83595     } catch (std::exception& e) {
83596       {
83597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83598       };
83599     } catch (Dali::DaliException e) {
83600       {
83601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83602       };
83603     } catch (...) {
83604       {
83605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83606       };
83607     }
83608   }
83609
83610   jresult = (void *)result;
83611   return jresult;
83612 }
83613
83614
83615 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83616   void * jresult ;
83617   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83618   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83619
83620   arg1 = (Dali::Toolkit::Popup *)jarg1;
83621   {
83622     try {
83623       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83624     } catch (std::out_of_range& e) {
83625       {
83626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83627       };
83628     } catch (std::exception& e) {
83629       {
83630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83631       };
83632     } catch (Dali::DaliException e) {
83633       {
83634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83635       };
83636     } catch (...) {
83637       {
83638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83639       };
83640     }
83641   }
83642
83643   jresult = (void *)result;
83644   return jresult;
83645 }
83646
83647
83648 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83649   void * jresult ;
83650   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83651   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83652
83653   arg1 = (Dali::Toolkit::Popup *)jarg1;
83654   {
83655     try {
83656       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83657     } catch (std::out_of_range& e) {
83658       {
83659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83660       };
83661     } catch (std::exception& e) {
83662       {
83663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83664       };
83665     } catch (Dali::DaliException e) {
83666       {
83667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83668       };
83669     } catch (...) {
83670       {
83671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83672       };
83673     }
83674   }
83675
83676   jresult = (void *)result;
83677   return jresult;
83678 }
83679
83680
83681 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83682   void * jresult ;
83683   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83684   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83685
83686   arg1 = (Dali::Toolkit::Popup *)jarg1;
83687   {
83688     try {
83689       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83690     } catch (std::out_of_range& e) {
83691       {
83692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83693       };
83694     } catch (std::exception& e) {
83695       {
83696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83697       };
83698     } catch (Dali::DaliException e) {
83699       {
83700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83701       };
83702     } catch (...) {
83703       {
83704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83705       };
83706     }
83707   }
83708
83709   jresult = (void *)result;
83710   return jresult;
83711 }
83712
83713
83714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83715   void * jresult ;
83716   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83717   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83718
83719   arg1 = (Dali::Toolkit::Popup *)jarg1;
83720   {
83721     try {
83722       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83723     } catch (std::out_of_range& e) {
83724       {
83725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83726       };
83727     } catch (std::exception& e) {
83728       {
83729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83730       };
83731     } catch (Dali::DaliException e) {
83732       {
83733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83734       };
83735     } catch (...) {
83736       {
83737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83738       };
83739     }
83740   }
83741
83742   jresult = (void *)result;
83743   return jresult;
83744 }
83745
83746
83747 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83748   int jresult ;
83749   int result;
83750
83751   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83752   jresult = (int)result;
83753   return jresult;
83754 }
83755
83756
83757 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83758   int jresult ;
83759   int result;
83760
83761   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83762   jresult = (int)result;
83763   return jresult;
83764 }
83765
83766
83767 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83768   int jresult ;
83769   int result;
83770
83771   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83772   jresult = (int)result;
83773   return jresult;
83774 }
83775
83776
83777 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83778   int jresult ;
83779   int result;
83780
83781   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83782   jresult = (int)result;
83783   return jresult;
83784 }
83785
83786
83787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83788   int jresult ;
83789   int result;
83790
83791   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83792   jresult = (int)result;
83793   return jresult;
83794 }
83795
83796
83797 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83798   int jresult ;
83799   int result;
83800
83801   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83802   jresult = (int)result;
83803   return jresult;
83804 }
83805
83806
83807 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83808   int jresult ;
83809   int result;
83810
83811   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83812   jresult = (int)result;
83813   return jresult;
83814 }
83815
83816
83817 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83818   int jresult ;
83819   int result;
83820
83821   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83822   jresult = (int)result;
83823   return jresult;
83824 }
83825
83826
83827 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83828   int jresult ;
83829   int result;
83830
83831   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83832   jresult = (int)result;
83833   return jresult;
83834 }
83835
83836
83837 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83838   void * jresult ;
83839   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83840
83841   {
83842     try {
83843       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83844     } catch (std::out_of_range& e) {
83845       {
83846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83847       };
83848     } catch (std::exception& e) {
83849       {
83850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83851       };
83852     } catch (Dali::DaliException e) {
83853       {
83854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83855       };
83856     } catch (...) {
83857       {
83858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83859       };
83860     }
83861   }
83862
83863   jresult = (void *)result;
83864   return jresult;
83865 }
83866
83867
83868 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83869   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83870
83871   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83872   {
83873     try {
83874       delete arg1;
83875     } catch (std::out_of_range& e) {
83876       {
83877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83878       };
83879     } catch (std::exception& e) {
83880       {
83881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83882       };
83883     } catch (Dali::DaliException e) {
83884       {
83885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83886       };
83887     } catch (...) {
83888       {
83889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83890       };
83891     }
83892   }
83893
83894 }
83895
83896
83897 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83898   void * jresult ;
83899   Dali::Toolkit::ProgressBar result;
83900
83901   {
83902     try {
83903       result = Dali::Toolkit::ProgressBar::New();
83904     } catch (std::out_of_range& e) {
83905       {
83906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83907       };
83908     } catch (std::exception& e) {
83909       {
83910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83911       };
83912     } catch (Dali::DaliException e) {
83913       {
83914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83915       };
83916     } catch (...) {
83917       {
83918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83919       };
83920     }
83921   }
83922
83923   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83924   return jresult;
83925 }
83926
83927
83928 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83929   void * jresult ;
83930   Dali::Toolkit::ProgressBar *result = 0 ;
83931
83932   {
83933     try {
83934       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83935     } catch (std::out_of_range& e) {
83936       {
83937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83938       };
83939     } catch (std::exception& e) {
83940       {
83941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83942       };
83943     } catch (Dali::DaliException e) {
83944       {
83945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83946       };
83947     } catch (...) {
83948       {
83949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83950       };
83951     }
83952   }
83953
83954   jresult = (void *)result;
83955   return jresult;
83956 }
83957
83958
83959 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83960   void * jresult ;
83961   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83962   Dali::Toolkit::ProgressBar *result = 0 ;
83963
83964   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83965   if (!arg1) {
83966     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83967     return 0;
83968   }
83969   {
83970     try {
83971       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83972     } catch (std::out_of_range& e) {
83973       {
83974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83975       };
83976     } catch (std::exception& e) {
83977       {
83978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83979       };
83980     } catch (Dali::DaliException e) {
83981       {
83982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83983       };
83984     } catch (...) {
83985       {
83986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83987       };
83988     }
83989   }
83990
83991   jresult = (void *)result;
83992   return jresult;
83993 }
83994
83995
83996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83997   void * jresult ;
83998   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83999   Dali::Toolkit::ProgressBar *arg2 = 0 ;
84000   Dali::Toolkit::ProgressBar *result = 0 ;
84001
84002   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84003   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
84004   if (!arg2) {
84005     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
84006     return 0;
84007   }
84008   {
84009     try {
84010       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
84011     } catch (std::out_of_range& e) {
84012       {
84013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84014       };
84015     } catch (std::exception& e) {
84016       {
84017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84018       };
84019     } catch (Dali::DaliException e) {
84020       {
84021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84022       };
84023     } catch (...) {
84024       {
84025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84026       };
84027     }
84028   }
84029
84030   jresult = (void *)result;
84031   return jresult;
84032 }
84033
84034
84035 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
84036   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
84037
84038   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84039   {
84040     try {
84041       delete arg1;
84042     } catch (std::out_of_range& e) {
84043       {
84044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84045       };
84046     } catch (std::exception& e) {
84047       {
84048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84049       };
84050     } catch (Dali::DaliException e) {
84051       {
84052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84053       };
84054     } catch (...) {
84055       {
84056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84057       };
84058     }
84059   }
84060
84061 }
84062
84063
84064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
84065   void * jresult ;
84066   Dali::BaseHandle arg1 ;
84067   Dali::BaseHandle *argp1 ;
84068   Dali::Toolkit::ProgressBar result;
84069
84070   argp1 = (Dali::BaseHandle *)jarg1;
84071   if (!argp1) {
84072     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84073     return 0;
84074   }
84075   arg1 = *argp1;
84076   {
84077     try {
84078       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
84079     } catch (std::out_of_range& e) {
84080       {
84081         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84082       };
84083     } catch (std::exception& e) {
84084       {
84085         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84086       };
84087     } catch (Dali::DaliException e) {
84088       {
84089         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84090       };
84091     } catch (...) {
84092       {
84093         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84094       };
84095     }
84096   }
84097
84098   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
84099   return jresult;
84100 }
84101
84102
84103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
84104   void * jresult ;
84105   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
84106   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
84107
84108   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
84109   {
84110     try {
84111       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
84112     } catch (std::out_of_range& e) {
84113       {
84114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84115       };
84116     } catch (std::exception& e) {
84117       {
84118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84119       };
84120     } catch (Dali::DaliException e) {
84121       {
84122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84123       };
84124     } catch (...) {
84125       {
84126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84127       };
84128     }
84129   }
84130
84131   jresult = (void *)result;
84132   return jresult;
84133 }
84134
84135
84136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
84137   void * jresult ;
84138   Dali::Toolkit::GaussianBlurView *result = 0 ;
84139
84140   {
84141     try {
84142       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
84143     } catch (std::out_of_range& e) {
84144       {
84145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84146       };
84147     } catch (std::exception& e) {
84148       {
84149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84150       };
84151     } catch (Dali::DaliException e) {
84152       {
84153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84154       };
84155     } catch (...) {
84156       {
84157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84158       };
84159     }
84160   }
84161
84162   jresult = (void *)result;
84163   return jresult;
84164 }
84165
84166
84167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
84168   void * jresult ;
84169   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
84170   Dali::Toolkit::GaussianBlurView *result = 0 ;
84171
84172   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84173   if (!arg1) {
84174     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
84175     return 0;
84176   }
84177   {
84178     try {
84179       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
84180     } catch (std::out_of_range& e) {
84181       {
84182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84183       };
84184     } catch (std::exception& e) {
84185       {
84186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84187       };
84188     } catch (Dali::DaliException e) {
84189       {
84190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84191       };
84192     } catch (...) {
84193       {
84194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84195       };
84196     }
84197   }
84198
84199   jresult = (void *)result;
84200   return jresult;
84201 }
84202
84203
84204 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
84205   void * jresult ;
84206   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84207   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
84208   Dali::Toolkit::GaussianBlurView *result = 0 ;
84209
84210   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84211   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
84212   if (!arg2) {
84213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
84214     return 0;
84215   }
84216   {
84217     try {
84218       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
84219     } catch (std::out_of_range& e) {
84220       {
84221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84222       };
84223     } catch (std::exception& e) {
84224       {
84225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84226       };
84227     } catch (Dali::DaliException e) {
84228       {
84229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84230       };
84231     } catch (...) {
84232       {
84233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84234       };
84235     }
84236   }
84237
84238   jresult = (void *)result;
84239   return jresult;
84240 }
84241
84242
84243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
84244   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84245
84246   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84247   {
84248     try {
84249       delete arg1;
84250     } catch (std::out_of_range& e) {
84251       {
84252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84253       };
84254     } catch (std::exception& e) {
84255       {
84256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84257       };
84258     } catch (Dali::DaliException e) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84261       };
84262     } catch (...) {
84263       {
84264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84265       };
84266     }
84267   }
84268
84269 }
84270
84271
84272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
84273   void * jresult ;
84274   Dali::BaseHandle arg1 ;
84275   Dali::BaseHandle *argp1 ;
84276   Dali::Toolkit::GaussianBlurView result;
84277
84278   argp1 = (Dali::BaseHandle *)jarg1;
84279   if (!argp1) {
84280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84281     return 0;
84282   }
84283   arg1 = *argp1;
84284   {
84285     try {
84286       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
84287     } catch (std::out_of_range& e) {
84288       {
84289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84290       };
84291     } catch (std::exception& e) {
84292       {
84293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84294       };
84295     } catch (Dali::DaliException e) {
84296       {
84297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84298       };
84299     } catch (...) {
84300       {
84301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84302       };
84303     }
84304   }
84305
84306   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84307   return jresult;
84308 }
84309
84310
84311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
84312   void * jresult ;
84313   Dali::Toolkit::GaussianBlurView result;
84314
84315   {
84316     try {
84317       result = Dali::Toolkit::GaussianBlurView::New();
84318     } catch (std::out_of_range& e) {
84319       {
84320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84321       };
84322     } catch (std::exception& e) {
84323       {
84324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84325       };
84326     } catch (Dali::DaliException e) {
84327       {
84328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84329       };
84330     } catch (...) {
84331       {
84332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84333       };
84334     }
84335   }
84336
84337   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84338   return jresult;
84339 }
84340
84341
84342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
84343   void * jresult ;
84344   unsigned int arg1 ;
84345   float arg2 ;
84346   Dali::Pixel::Format arg3 ;
84347   float arg4 ;
84348   float arg5 ;
84349   bool arg6 ;
84350   Dali::Toolkit::GaussianBlurView result;
84351
84352   arg1 = (unsigned int)jarg1;
84353   arg2 = (float)jarg2;
84354   arg3 = (Dali::Pixel::Format)jarg3;
84355   arg4 = (float)jarg4;
84356   arg5 = (float)jarg5;
84357   arg6 = jarg6 ? true : false;
84358   {
84359     try {
84360       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
84361     } catch (std::out_of_range& e) {
84362       {
84363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84364       };
84365     } catch (std::exception& e) {
84366       {
84367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84368       };
84369     } catch (Dali::DaliException e) {
84370       {
84371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84372       };
84373     } catch (...) {
84374       {
84375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84376       };
84377     }
84378   }
84379
84380   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84381   return jresult;
84382 }
84383
84384
84385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
84386   void * jresult ;
84387   unsigned int arg1 ;
84388   float arg2 ;
84389   Dali::Pixel::Format arg3 ;
84390   float arg4 ;
84391   float arg5 ;
84392   Dali::Toolkit::GaussianBlurView result;
84393
84394   arg1 = (unsigned int)jarg1;
84395   arg2 = (float)jarg2;
84396   arg3 = (Dali::Pixel::Format)jarg3;
84397   arg4 = (float)jarg4;
84398   arg5 = (float)jarg5;
84399   {
84400     try {
84401       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
84402     } catch (std::out_of_range& e) {
84403       {
84404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84405       };
84406     } catch (std::exception& e) {
84407       {
84408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84409       };
84410     } catch (Dali::DaliException e) {
84411       {
84412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84413       };
84414     } catch (...) {
84415       {
84416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84417       };
84418     }
84419   }
84420
84421   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
84422   return jresult;
84423 }
84424
84425
84426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
84427   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84428   Dali::Actor arg2 ;
84429   Dali::Actor *argp2 ;
84430
84431   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84432   argp2 = (Dali::Actor *)jarg2;
84433   if (!argp2) {
84434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84435     return ;
84436   }
84437   arg2 = *argp2;
84438   {
84439     try {
84440       (arg1)->Add(arg2);
84441     } catch (std::out_of_range& e) {
84442       {
84443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84444       };
84445     } catch (std::exception& e) {
84446       {
84447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84448       };
84449     } catch (Dali::DaliException e) {
84450       {
84451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84452       };
84453     } catch (...) {
84454       {
84455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84456       };
84457     }
84458   }
84459
84460 }
84461
84462
84463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
84464   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84465   Dali::Actor arg2 ;
84466   Dali::Actor *argp2 ;
84467
84468   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84469   argp2 = (Dali::Actor *)jarg2;
84470   if (!argp2) {
84471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
84472     return ;
84473   }
84474   arg2 = *argp2;
84475   {
84476     try {
84477       (arg1)->Remove(arg2);
84478     } catch (std::out_of_range& e) {
84479       {
84480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84481       };
84482     } catch (std::exception& e) {
84483       {
84484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84485       };
84486     } catch (Dali::DaliException e) {
84487       {
84488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84489       };
84490     } catch (...) {
84491       {
84492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84493       };
84494     }
84495   }
84496
84497 }
84498
84499
84500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84501   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84502
84503   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84504   {
84505     try {
84506       (arg1)->Activate();
84507     } catch (std::out_of_range& e) {
84508       {
84509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84510       };
84511     } catch (std::exception& e) {
84512       {
84513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84514       };
84515     } catch (Dali::DaliException e) {
84516       {
84517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84518       };
84519     } catch (...) {
84520       {
84521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84522       };
84523     }
84524   }
84525
84526 }
84527
84528
84529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84530   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84531
84532   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84533   {
84534     try {
84535       (arg1)->ActivateOnce();
84536     } catch (std::out_of_range& e) {
84537       {
84538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84539       };
84540     } catch (std::exception& e) {
84541       {
84542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84543       };
84544     } catch (Dali::DaliException e) {
84545       {
84546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84547       };
84548     } catch (...) {
84549       {
84550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84551       };
84552     }
84553   }
84554
84555 }
84556
84557
84558 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84559   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84560
84561   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84562   {
84563     try {
84564       (arg1)->Deactivate();
84565     } catch (std::out_of_range& e) {
84566       {
84567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84568       };
84569     } catch (std::exception& e) {
84570       {
84571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84572       };
84573     } catch (Dali::DaliException e) {
84574       {
84575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84576       };
84577     } catch (...) {
84578       {
84579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84580       };
84581     }
84582   }
84583
84584 }
84585
84586
84587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84588   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84589   Dali::Texture arg2 ;
84590   Dali::FrameBuffer arg3 ;
84591   Dali::Texture *argp2 ;
84592   Dali::FrameBuffer *argp3 ;
84593
84594   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84595   argp2 = (Dali::Texture *)jarg2;
84596   if (!argp2) {
84597     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84598     return ;
84599   }
84600   arg2 = *argp2;
84601   argp3 = (Dali::FrameBuffer *)jarg3;
84602   if (!argp3) {
84603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84604     return ;
84605   }
84606   arg3 = *argp3;
84607   {
84608     try {
84609       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84610     } catch (std::out_of_range& e) {
84611       {
84612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84613       };
84614     } catch (std::exception& e) {
84615       {
84616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84617       };
84618     } catch (Dali::DaliException e) {
84619       {
84620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84621       };
84622     } catch (...) {
84623       {
84624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84625       };
84626     }
84627   }
84628
84629 }
84630
84631
84632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84633   int jresult ;
84634   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84635   Dali::Property::Index result;
84636
84637   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84638   {
84639     try {
84640       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84641     } catch (std::out_of_range& e) {
84642       {
84643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84644       };
84645     } catch (std::exception& e) {
84646       {
84647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84648       };
84649     } catch (Dali::DaliException e) {
84650       {
84651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84652       };
84653     } catch (...) {
84654       {
84655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84656       };
84657     }
84658   }
84659
84660   jresult = result;
84661   return jresult;
84662 }
84663
84664
84665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84666   void * jresult ;
84667   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84668   Dali::FrameBuffer result;
84669
84670   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84671   {
84672     try {
84673       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84674     } catch (std::out_of_range& e) {
84675       {
84676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84677       };
84678     } catch (std::exception& e) {
84679       {
84680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84681       };
84682     } catch (Dali::DaliException e) {
84683       {
84684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84685       };
84686     } catch (...) {
84687       {
84688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84689       };
84690     }
84691   }
84692
84693   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84694   return jresult;
84695 }
84696
84697
84698 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84699   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84700   Dali::Vector4 *arg2 = 0 ;
84701
84702   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84703   arg2 = (Dali::Vector4 *)jarg2;
84704   if (!arg2) {
84705     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84706     return ;
84707   }
84708   {
84709     try {
84710       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84711     } catch (std::out_of_range& e) {
84712       {
84713         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84714       };
84715     } catch (std::exception& e) {
84716       {
84717         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84718       };
84719     } catch (Dali::DaliException e) {
84720       {
84721         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84722       };
84723     } catch (...) {
84724       {
84725         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84726       };
84727     }
84728   }
84729
84730 }
84731
84732
84733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84734   void * jresult ;
84735   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84736   Dali::Vector4 result;
84737
84738   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84739   {
84740     try {
84741       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84742     } catch (std::out_of_range& e) {
84743       {
84744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84745       };
84746     } catch (std::exception& e) {
84747       {
84748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84749       };
84750     } catch (Dali::DaliException e) {
84751       {
84752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84753       };
84754     } catch (...) {
84755       {
84756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84757       };
84758     }
84759   }
84760
84761   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84762   return jresult;
84763 }
84764
84765
84766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84767   void * jresult ;
84768   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84769   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84770
84771   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84772   {
84773     try {
84774       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84775     } catch (std::out_of_range& e) {
84776       {
84777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84778       };
84779     } catch (std::exception& e) {
84780       {
84781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84782       };
84783     } catch (Dali::DaliException e) {
84784       {
84785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84786       };
84787     } catch (...) {
84788       {
84789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84790       };
84791     }
84792   }
84793
84794   jresult = (void *)result;
84795   return jresult;
84796 }
84797
84798
84799 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84800   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84801
84802   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84803   {
84804     try {
84805       delete arg1;
84806     } catch (std::out_of_range& e) {
84807       {
84808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84809       };
84810     } catch (std::exception& e) {
84811       {
84812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84813       };
84814     } catch (Dali::DaliException e) {
84815       {
84816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84817       };
84818     } catch (...) {
84819       {
84820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84821       };
84822     }
84823   }
84824
84825 }
84826
84827
84828 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84829   unsigned int jresult ;
84830   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84831   unsigned int result;
84832
84833   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84834   {
84835     try {
84836       result = (unsigned int)(arg1)->GetNumberOfPages();
84837     } catch (std::out_of_range& e) {
84838       {
84839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84840       };
84841     } catch (std::exception& e) {
84842       {
84843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84844       };
84845     } catch (Dali::DaliException e) {
84846       {
84847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84848       };
84849     } catch (...) {
84850       {
84851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84852       };
84853     }
84854   }
84855
84856   jresult = result;
84857   return jresult;
84858 }
84859
84860
84861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84862   void * jresult ;
84863   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84864   unsigned int arg2 ;
84865   Dali::Texture result;
84866
84867   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84868   arg2 = (unsigned int)jarg2;
84869   {
84870     try {
84871       result = (arg1)->NewPage(arg2);
84872     } catch (std::out_of_range& e) {
84873       {
84874         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84875       };
84876     } catch (std::exception& e) {
84877       {
84878         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84879       };
84880     } catch (Dali::DaliException e) {
84881       {
84882         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84883       };
84884     } catch (...) {
84885       {
84886         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84887       };
84888     }
84889   }
84890
84891   jresult = new Dali::Texture((const Dali::Texture &)result);
84892   return jresult;
84893 }
84894
84895
84896 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84897   int jresult ;
84898   int result;
84899
84900   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84901   jresult = (int)result;
84902   return jresult;
84903 }
84904
84905
84906 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84907   int jresult ;
84908   int result;
84909
84910   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84911   jresult = (int)result;
84912   return jresult;
84913 }
84914
84915
84916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84917   int jresult ;
84918   int result;
84919
84920   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84921   jresult = (int)result;
84922   return jresult;
84923 }
84924
84925
84926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84927   void * jresult ;
84928   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84929
84930   {
84931     try {
84932       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84933     } catch (std::out_of_range& e) {
84934       {
84935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84936       };
84937     } catch (std::exception& e) {
84938       {
84939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84940       };
84941     } catch (Dali::DaliException e) {
84942       {
84943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84944       };
84945     } catch (...) {
84946       {
84947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84948       };
84949     }
84950   }
84951
84952   jresult = (void *)result;
84953   return jresult;
84954 }
84955
84956
84957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84958   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84959
84960   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84961   {
84962     try {
84963       delete arg1;
84964     } catch (std::out_of_range& e) {
84965       {
84966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84967       };
84968     } catch (std::exception& e) {
84969       {
84970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84971       };
84972     } catch (Dali::DaliException e) {
84973       {
84974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84975       };
84976     } catch (...) {
84977       {
84978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84979       };
84980     }
84981   }
84982
84983 }
84984
84985
84986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84987   void * jresult ;
84988   Dali::Toolkit::PageTurnView *result = 0 ;
84989
84990   {
84991     try {
84992       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84993     } catch (std::out_of_range& e) {
84994       {
84995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84996       };
84997     } catch (std::exception& e) {
84998       {
84999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85000       };
85001     } catch (Dali::DaliException e) {
85002       {
85003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85004       };
85005     } catch (...) {
85006       {
85007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85008       };
85009     }
85010   }
85011
85012   jresult = (void *)result;
85013   return jresult;
85014 }
85015
85016
85017 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
85018   void * jresult ;
85019   Dali::Toolkit::PageTurnView *arg1 = 0 ;
85020   Dali::Toolkit::PageTurnView *result = 0 ;
85021
85022   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85023   if (!arg1) {
85024     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
85025     return 0;
85026   }
85027   {
85028     try {
85029       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
85030     } catch (std::out_of_range& e) {
85031       {
85032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85033       };
85034     } catch (std::exception& e) {
85035       {
85036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85037       };
85038     } catch (Dali::DaliException e) {
85039       {
85040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85041       };
85042     } catch (...) {
85043       {
85044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85045       };
85046     }
85047   }
85048
85049   jresult = (void *)result;
85050   return jresult;
85051 }
85052
85053
85054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
85055   void * jresult ;
85056   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85057   Dali::Toolkit::PageTurnView *arg2 = 0 ;
85058   Dali::Toolkit::PageTurnView *result = 0 ;
85059
85060   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85061   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
85062   if (!arg2) {
85063     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
85064     return 0;
85065   }
85066   {
85067     try {
85068       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
85069     } catch (std::out_of_range& e) {
85070       {
85071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85072       };
85073     } catch (std::exception& e) {
85074       {
85075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85076       };
85077     } catch (Dali::DaliException e) {
85078       {
85079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85080       };
85081     } catch (...) {
85082       {
85083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85084       };
85085     }
85086   }
85087
85088   jresult = (void *)result;
85089   return jresult;
85090 }
85091
85092
85093 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
85094   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85095
85096   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85097   {
85098     try {
85099       delete arg1;
85100     } catch (std::out_of_range& e) {
85101       {
85102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85103       };
85104     } catch (std::exception& e) {
85105       {
85106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85107       };
85108     } catch (Dali::DaliException e) {
85109       {
85110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85111       };
85112     } catch (...) {
85113       {
85114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85115       };
85116     }
85117   }
85118
85119 }
85120
85121
85122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
85123   void * jresult ;
85124   Dali::BaseHandle arg1 ;
85125   Dali::BaseHandle *argp1 ;
85126   Dali::Toolkit::PageTurnView result;
85127
85128   argp1 = (Dali::BaseHandle *)jarg1;
85129   if (!argp1) {
85130     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85131     return 0;
85132   }
85133   arg1 = *argp1;
85134   {
85135     try {
85136       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
85137     } catch (std::out_of_range& e) {
85138       {
85139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85140       };
85141     } catch (std::exception& e) {
85142       {
85143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85144       };
85145     } catch (Dali::DaliException e) {
85146       {
85147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85148       };
85149     } catch (...) {
85150       {
85151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85152       };
85153     }
85154   }
85155
85156   jresult = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
85157   return jresult;
85158 }
85159
85160
85161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
85162   void * jresult ;
85163   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85164   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
85165
85166   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85167   {
85168     try {
85169       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
85170     } catch (std::out_of_range& e) {
85171       {
85172         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85173       };
85174     } catch (std::exception& e) {
85175       {
85176         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85177       };
85178     } catch (Dali::DaliException e) {
85179       {
85180         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85181       };
85182     } catch (...) {
85183       {
85184         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85185       };
85186     }
85187   }
85188
85189   jresult = (void *)result;
85190   return jresult;
85191 }
85192
85193
85194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
85195   void * jresult ;
85196   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85197   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
85198
85199   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85200   {
85201     try {
85202       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
85203     } catch (std::out_of_range& e) {
85204       {
85205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85206       };
85207     } catch (std::exception& e) {
85208       {
85209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85210       };
85211     } catch (Dali::DaliException e) {
85212       {
85213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85214       };
85215     } catch (...) {
85216       {
85217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85218       };
85219     }
85220   }
85221
85222   jresult = (void *)result;
85223   return jresult;
85224 }
85225
85226
85227 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
85228   void * jresult ;
85229   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85230   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85231
85232   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85233   {
85234     try {
85235       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
85236     } catch (std::out_of_range& e) {
85237       {
85238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85239       };
85240     } catch (std::exception& e) {
85241       {
85242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85243       };
85244     } catch (Dali::DaliException e) {
85245       {
85246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85247       };
85248     } catch (...) {
85249       {
85250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85251       };
85252     }
85253   }
85254
85255   jresult = (void *)result;
85256   return jresult;
85257 }
85258
85259
85260 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
85261   void * jresult ;
85262   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
85263   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
85264
85265   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
85266   {
85267     try {
85268       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
85269     } catch (std::out_of_range& e) {
85270       {
85271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85272       };
85273     } catch (std::exception& e) {
85274       {
85275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85276       };
85277     } catch (Dali::DaliException e) {
85278       {
85279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85280       };
85281     } catch (...) {
85282       {
85283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85284       };
85285     }
85286   }
85287
85288   jresult = (void *)result;
85289   return jresult;
85290 }
85291
85292
85293 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
85294   void * jresult ;
85295   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85296
85297   {
85298     try {
85299       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
85300     } catch (std::out_of_range& e) {
85301       {
85302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85303       };
85304     } catch (std::exception& e) {
85305       {
85306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85307       };
85308     } catch (Dali::DaliException e) {
85309       {
85310         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85311       };
85312     } catch (...) {
85313       {
85314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85315       };
85316     }
85317   }
85318
85319   jresult = (void *)result;
85320   return jresult;
85321 }
85322
85323
85324 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
85325   void * jresult ;
85326   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
85327   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85328
85329   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85330   if (!arg1) {
85331     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85332     return 0;
85333   }
85334   {
85335     try {
85336       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
85337     } catch (std::out_of_range& e) {
85338       {
85339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85340       };
85341     } catch (std::exception& e) {
85342       {
85343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85344       };
85345     } catch (Dali::DaliException e) {
85346       {
85347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85348       };
85349     } catch (...) {
85350       {
85351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85352       };
85353     }
85354   }
85355
85356   jresult = (void *)result;
85357   return jresult;
85358 }
85359
85360
85361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
85362   void * jresult ;
85363   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85364   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
85365   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
85366
85367   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85368   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
85369   if (!arg2) {
85370     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
85371     return 0;
85372   }
85373   {
85374     try {
85375       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
85376     } catch (std::out_of_range& e) {
85377       {
85378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85379       };
85380     } catch (std::exception& e) {
85381       {
85382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85383       };
85384     } catch (Dali::DaliException e) {
85385       {
85386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85387       };
85388     } catch (...) {
85389       {
85390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85391       };
85392     }
85393   }
85394
85395   jresult = (void *)result;
85396   return jresult;
85397 }
85398
85399
85400 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
85401   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
85402
85403   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
85404   {
85405     try {
85406       delete arg1;
85407     } catch (std::out_of_range& e) {
85408       {
85409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85410       };
85411     } catch (std::exception& e) {
85412       {
85413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85414       };
85415     } catch (Dali::DaliException e) {
85416       {
85417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85418       };
85419     } catch (...) {
85420       {
85421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85422       };
85423     }
85424   }
85425
85426 }
85427
85428
85429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
85430   void * jresult ;
85431   Dali::Toolkit::PageFactory *arg1 = 0 ;
85432   Dali::Vector2 *arg2 = 0 ;
85433   Dali::Toolkit::PageTurnLandscapeView result;
85434
85435   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85436   if (!arg1) {
85437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85438     return 0;
85439   }
85440   arg2 = (Dali::Vector2 *)jarg2;
85441   if (!arg2) {
85442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85443     return 0;
85444   }
85445   {
85446     try {
85447       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
85448     } catch (std::out_of_range& e) {
85449       {
85450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85451       };
85452     } catch (std::exception& e) {
85453       {
85454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85455       };
85456     } catch (Dali::DaliException e) {
85457       {
85458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85459       };
85460     } catch (...) {
85461       {
85462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85463       };
85464     }
85465   }
85466
85467   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85468   return jresult;
85469 }
85470
85471
85472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
85473   void * jresult ;
85474   Dali::BaseHandle arg1 ;
85475   Dali::BaseHandle *argp1 ;
85476   Dali::Toolkit::PageTurnLandscapeView result;
85477
85478   argp1 = (Dali::BaseHandle *)jarg1;
85479   if (!argp1) {
85480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85481     return 0;
85482   }
85483   arg1 = *argp1;
85484   {
85485     try {
85486       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
85487     } catch (std::out_of_range& e) {
85488       {
85489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85490       };
85491     } catch (std::exception& e) {
85492       {
85493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85494       };
85495     } catch (Dali::DaliException e) {
85496       {
85497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85498       };
85499     } catch (...) {
85500       {
85501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85502       };
85503     }
85504   }
85505
85506   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85507   return jresult;
85508 }
85509
85510
85511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85512   void * jresult ;
85513   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85514
85515   {
85516     try {
85517       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85518     } catch (std::out_of_range& e) {
85519       {
85520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85521       };
85522     } catch (std::exception& e) {
85523       {
85524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85525       };
85526     } catch (Dali::DaliException e) {
85527       {
85528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85529       };
85530     } catch (...) {
85531       {
85532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85533       };
85534     }
85535   }
85536
85537   jresult = (void *)result;
85538   return jresult;
85539 }
85540
85541
85542 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85543   void * jresult ;
85544   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85545   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85546
85547   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85548   if (!arg1) {
85549     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85550     return 0;
85551   }
85552   {
85553     try {
85554       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85555     } catch (std::out_of_range& e) {
85556       {
85557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85558       };
85559     } catch (std::exception& e) {
85560       {
85561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85562       };
85563     } catch (Dali::DaliException e) {
85564       {
85565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85566       };
85567     } catch (...) {
85568       {
85569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85570       };
85571     }
85572   }
85573
85574   jresult = (void *)result;
85575   return jresult;
85576 }
85577
85578
85579 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85580   void * jresult ;
85581   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85582   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85583   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85584
85585   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85586   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85587   if (!arg2) {
85588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85589     return 0;
85590   }
85591   {
85592     try {
85593       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85594     } catch (std::out_of_range& e) {
85595       {
85596         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85597       };
85598     } catch (std::exception& e) {
85599       {
85600         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85601       };
85602     } catch (Dali::DaliException e) {
85603       {
85604         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85605       };
85606     } catch (...) {
85607       {
85608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85609       };
85610     }
85611   }
85612
85613   jresult = (void *)result;
85614   return jresult;
85615 }
85616
85617
85618 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85619   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85620
85621   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85622   {
85623     try {
85624       delete arg1;
85625     } catch (std::out_of_range& e) {
85626       {
85627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85628       };
85629     } catch (std::exception& e) {
85630       {
85631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85632       };
85633     } catch (Dali::DaliException e) {
85634       {
85635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85636       };
85637     } catch (...) {
85638       {
85639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85640       };
85641     }
85642   }
85643
85644 }
85645
85646
85647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85648   void * jresult ;
85649   Dali::Toolkit::PageFactory *arg1 = 0 ;
85650   Dali::Vector2 *arg2 = 0 ;
85651   Dali::Toolkit::PageTurnPortraitView result;
85652
85653   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85654   if (!arg1) {
85655     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85656     return 0;
85657   }
85658   arg2 = (Dali::Vector2 *)jarg2;
85659   if (!arg2) {
85660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85661     return 0;
85662   }
85663   {
85664     try {
85665       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
85666     } catch (std::out_of_range& e) {
85667       {
85668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85669       };
85670     } catch (std::exception& e) {
85671       {
85672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85673       };
85674     } catch (Dali::DaliException e) {
85675       {
85676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85677       };
85678     } catch (...) {
85679       {
85680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85681       };
85682     }
85683   }
85684
85685   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85686   return jresult;
85687 }
85688
85689
85690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85691   void * jresult ;
85692   Dali::BaseHandle arg1 ;
85693   Dali::BaseHandle *argp1 ;
85694   Dali::Toolkit::PageTurnPortraitView result;
85695
85696   argp1 = (Dali::BaseHandle *)jarg1;
85697   if (!argp1) {
85698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85699     return 0;
85700   }
85701   arg1 = *argp1;
85702   {
85703     try {
85704       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85705     } catch (std::out_of_range& e) {
85706       {
85707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85708       };
85709     } catch (std::exception& e) {
85710       {
85711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85712       };
85713     } catch (Dali::DaliException e) {
85714       {
85715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85716       };
85717     } catch (...) {
85718       {
85719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85720       };
85721     }
85722   }
85723
85724   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85725   return jresult;
85726 }
85727
85728
85729 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85730   int jresult ;
85731   int result;
85732
85733   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85734   jresult = (int)result;
85735   return jresult;
85736 }
85737
85738
85739 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85740   int jresult ;
85741   int result;
85742
85743   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85744   jresult = (int)result;
85745   return jresult;
85746 }
85747
85748
85749 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85750   int jresult ;
85751   int result;
85752
85753   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85754   jresult = (int)result;
85755   return jresult;
85756 }
85757
85758
85759 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85760   void * jresult ;
85761   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85762
85763   {
85764     try {
85765       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85766     } catch (std::out_of_range& e) {
85767       {
85768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85769       };
85770     } catch (std::exception& e) {
85771       {
85772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85773       };
85774     } catch (Dali::DaliException e) {
85775       {
85776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85777       };
85778     } catch (...) {
85779       {
85780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85781       };
85782     }
85783   }
85784
85785   jresult = (void *)result;
85786   return jresult;
85787 }
85788
85789
85790 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85791   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85792
85793   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85794   {
85795     try {
85796       delete arg1;
85797     } catch (std::out_of_range& e) {
85798       {
85799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85800       };
85801     } catch (std::exception& e) {
85802       {
85803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85804       };
85805     } catch (Dali::DaliException e) {
85806       {
85807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85808       };
85809     } catch (...) {
85810       {
85811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85812       };
85813     }
85814   }
85815
85816 }
85817
85818
85819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85820   void * jresult ;
85821   Dali::Toolkit::ToggleButton *result = 0 ;
85822
85823   {
85824     try {
85825       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85826     } catch (std::out_of_range& e) {
85827       {
85828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85829       };
85830     } catch (std::exception& e) {
85831       {
85832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85833       };
85834     } catch (Dali::DaliException e) {
85835       {
85836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85837       };
85838     } catch (...) {
85839       {
85840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85841       };
85842     }
85843   }
85844
85845   jresult = (void *)result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85851   void * jresult ;
85852   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85853   Dali::Toolkit::ToggleButton *result = 0 ;
85854
85855   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85856   if (!arg1) {
85857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85858     return 0;
85859   }
85860   {
85861     try {
85862       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85863     } catch (std::out_of_range& e) {
85864       {
85865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85866       };
85867     } catch (std::exception& e) {
85868       {
85869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85870       };
85871     } catch (Dali::DaliException e) {
85872       {
85873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85874       };
85875     } catch (...) {
85876       {
85877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85878       };
85879     }
85880   }
85881
85882   jresult = (void *)result;
85883   return jresult;
85884 }
85885
85886
85887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85888   void * jresult ;
85889   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85890   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85891   Dali::Toolkit::ToggleButton *result = 0 ;
85892
85893   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85894   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85895   if (!arg2) {
85896     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85897     return 0;
85898   }
85899   {
85900     try {
85901       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85902     } catch (std::out_of_range& e) {
85903       {
85904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85905       };
85906     } catch (std::exception& e) {
85907       {
85908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85909       };
85910     } catch (Dali::DaliException e) {
85911       {
85912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85913       };
85914     } catch (...) {
85915       {
85916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85917       };
85918     }
85919   }
85920
85921   jresult = (void *)result;
85922   return jresult;
85923 }
85924
85925
85926 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85927   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85928
85929   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85930   {
85931     try {
85932       delete arg1;
85933     } catch (std::out_of_range& e) {
85934       {
85935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85936       };
85937     } catch (std::exception& e) {
85938       {
85939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85940       };
85941     } catch (Dali::DaliException e) {
85942       {
85943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85944       };
85945     } catch (...) {
85946       {
85947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85948       };
85949     }
85950   }
85951
85952 }
85953
85954
85955 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85956   void * jresult ;
85957   Dali::Toolkit::ToggleButton result;
85958
85959   {
85960     try {
85961       result = Dali::Toolkit::ToggleButton::New();
85962     } catch (std::out_of_range& e) {
85963       {
85964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85965       };
85966     } catch (std::exception& e) {
85967       {
85968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85969       };
85970     } catch (Dali::DaliException e) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85973       };
85974     } catch (...) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85977       };
85978     }
85979   }
85980
85981   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85982   return jresult;
85983 }
85984
85985
85986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85987   void * jresult ;
85988   Dali::BaseHandle arg1 ;
85989   Dali::BaseHandle *argp1 ;
85990   Dali::Toolkit::ToggleButton result;
85991
85992   argp1 = (Dali::BaseHandle *)jarg1;
85993   if (!argp1) {
85994     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85995     return 0;
85996   }
85997   arg1 = *argp1;
85998   {
85999     try {
86000       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
86001     } catch (std::out_of_range& e) {
86002       {
86003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86004       };
86005     } catch (std::exception& e) {
86006       {
86007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86008       };
86009     } catch (Dali::DaliException e) {
86010       {
86011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86012       };
86013     } catch (...) {
86014       {
86015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86016       };
86017     }
86018   }
86019
86020   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
86021   return jresult;
86022 }
86023
86024
86025 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
86026   void * jresult ;
86027   Dali::Toolkit::Visual::Base *result = 0 ;
86028
86029   {
86030     try {
86031       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
86032     } catch (std::out_of_range& e) {
86033       {
86034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86035       };
86036     } catch (std::exception& e) {
86037       {
86038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86039       };
86040     } catch (Dali::DaliException e) {
86041       {
86042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86043       };
86044     } catch (...) {
86045       {
86046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86047       };
86048     }
86049   }
86050
86051   jresult = (void *)result;
86052   return jresult;
86053 }
86054
86055
86056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
86057   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86058
86059   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86060   {
86061     try {
86062       delete arg1;
86063     } catch (std::out_of_range& e) {
86064       {
86065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86066       };
86067     } catch (std::exception& e) {
86068       {
86069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86070       };
86071     } catch (Dali::DaliException e) {
86072       {
86073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86074       };
86075     } catch (...) {
86076       {
86077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86078       };
86079     }
86080   }
86081
86082 }
86083
86084
86085 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
86086   void * jresult ;
86087   Dali::Toolkit::Visual::Base *arg1 = 0 ;
86088   Dali::Toolkit::Visual::Base *result = 0 ;
86089
86090   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86091   if (!arg1) {
86092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
86093     return 0;
86094   }
86095   {
86096     try {
86097       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
86098     } catch (std::out_of_range& e) {
86099       {
86100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86101       };
86102     } catch (std::exception& e) {
86103       {
86104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86105       };
86106     } catch (Dali::DaliException e) {
86107       {
86108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86109       };
86110     } catch (...) {
86111       {
86112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86113       };
86114     }
86115   }
86116
86117   jresult = (void *)result;
86118   return jresult;
86119 }
86120
86121
86122 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
86123   void * jresult ;
86124   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86125   Dali::Toolkit::Visual::Base *arg2 = 0 ;
86126   Dali::Toolkit::Visual::Base *result = 0 ;
86127
86128   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86129   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
86130   if (!arg2) {
86131     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
86132     return 0;
86133   }
86134   {
86135     try {
86136       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
86137     } catch (std::out_of_range& e) {
86138       {
86139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86140       };
86141     } catch (std::exception& e) {
86142       {
86143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86144       };
86145     } catch (Dali::DaliException e) {
86146       {
86147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86148       };
86149     } catch (...) {
86150       {
86151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86152       };
86153     }
86154   }
86155
86156   jresult = (void *)result;
86157   return jresult;
86158 }
86159
86160
86161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
86162   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86163   std::string *arg2 = 0 ;
86164
86165   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86166   if (!jarg2) {
86167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86168     return ;
86169   }
86170   std::string arg2_str(jarg2);
86171   arg2 = &arg2_str;
86172   {
86173     try {
86174       (arg1)->SetName((std::string const &)*arg2);
86175     } catch (std::out_of_range& e) {
86176       {
86177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86178       };
86179     } catch (std::exception& e) {
86180       {
86181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86182       };
86183     } catch (Dali::DaliException e) {
86184       {
86185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86186       };
86187     } catch (...) {
86188       {
86189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86190       };
86191     }
86192   }
86193
86194
86195   //argout typemap for const std::string&
86196
86197 }
86198
86199
86200 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
86201   char * jresult ;
86202   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86203   std::string *result = 0 ;
86204
86205   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86206   {
86207     try {
86208       result = (std::string *) &(arg1)->GetName();
86209     } catch (std::out_of_range& e) {
86210       {
86211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86212       };
86213     } catch (std::exception& e) {
86214       {
86215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86216       };
86217     } catch (Dali::DaliException e) {
86218       {
86219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86220       };
86221     } catch (...) {
86222       {
86223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86224       };
86225     }
86226   }
86227
86228   jresult = SWIG_csharp_string_callback(result->c_str());
86229   return jresult;
86230 }
86231
86232
86233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
86234   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86235   Dali::Property::Map *arg2 = 0 ;
86236   Dali::Size arg3 ;
86237   Dali::Size *argp3 ;
86238
86239   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86240   arg2 = (Dali::Property::Map *)jarg2;
86241   if (!arg2) {
86242     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86243     return ;
86244   }
86245   argp3 = (Dali::Size *)jarg3;
86246   if (!argp3) {
86247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
86248     return ;
86249   }
86250   arg3 = *argp3;
86251   {
86252     try {
86253       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
86254     } catch (std::out_of_range& e) {
86255       {
86256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86257       };
86258     } catch (std::exception& e) {
86259       {
86260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86261       };
86262     } catch (Dali::DaliException e) {
86263       {
86264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86265       };
86266     } catch (...) {
86267       {
86268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86269       };
86270     }
86271   }
86272
86273 }
86274
86275
86276 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
86277   float jresult ;
86278   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86279   float arg2 ;
86280   float result;
86281
86282   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86283   arg2 = (float)jarg2;
86284   {
86285     try {
86286       result = (float)(arg1)->GetHeightForWidth(arg2);
86287     } catch (std::out_of_range& e) {
86288       {
86289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86290       };
86291     } catch (std::exception& e) {
86292       {
86293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86294       };
86295     } catch (Dali::DaliException e) {
86296       {
86297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86298       };
86299     } catch (...) {
86300       {
86301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86302       };
86303     }
86304   }
86305
86306   jresult = result;
86307   return jresult;
86308 }
86309
86310
86311 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
86312   float jresult ;
86313   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86314   float arg2 ;
86315   float result;
86316
86317   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86318   arg2 = (float)jarg2;
86319   {
86320     try {
86321       result = (float)(arg1)->GetWidthForHeight(arg2);
86322     } catch (std::out_of_range& e) {
86323       {
86324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86325       };
86326     } catch (std::exception& e) {
86327       {
86328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86329       };
86330     } catch (Dali::DaliException e) {
86331       {
86332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86333       };
86334     } catch (...) {
86335       {
86336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86337       };
86338     }
86339   }
86340
86341   jresult = result;
86342   return jresult;
86343 }
86344
86345
86346 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
86347   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86348   Dali::Vector2 *arg2 = 0 ;
86349
86350   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86351   arg2 = (Dali::Vector2 *)jarg2;
86352   if (!arg2) {
86353     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
86354     return ;
86355   }
86356   {
86357     try {
86358       (arg1)->GetNaturalSize(*arg2);
86359     } catch (std::out_of_range& e) {
86360       {
86361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86362       };
86363     } catch (std::exception& e) {
86364       {
86365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86366       };
86367     } catch (Dali::DaliException e) {
86368       {
86369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86370       };
86371     } catch (...) {
86372       {
86373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86374       };
86375     }
86376   }
86377
86378 }
86379
86380
86381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
86382   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86383   float arg2 ;
86384
86385   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86386   arg2 = (int)jarg2;
86387   {
86388     try {
86389       (arg1)->SetDepthIndex(arg2);
86390     } catch (std::out_of_range& e) {
86391       {
86392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86393       };
86394     } catch (std::exception& e) {
86395       {
86396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86397       };
86398     } catch (Dali::DaliException e) {
86399       {
86400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86401       };
86402     } catch (...) {
86403       {
86404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86405       };
86406     }
86407   }
86408
86409 }
86410
86411
86412 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
86413   int jresult ;
86414   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86415   int result;
86416
86417   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86418   {
86419     try {
86420       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
86421     } catch (std::out_of_range& e) {
86422       {
86423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86424       };
86425     } catch (std::exception& e) {
86426       {
86427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86428       };
86429     } catch (Dali::DaliException e) {
86430       {
86431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86432       };
86433     } catch (...) {
86434       {
86435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86436       };
86437     }
86438   }
86439
86440   jresult = result;
86441   return jresult;
86442 }
86443
86444
86445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
86446   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
86447   Dali::Property::Map *arg2 = 0 ;
86448
86449   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
86450   arg2 = (Dali::Property::Map *)jarg2;
86451   if (!arg2) {
86452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
86453     return ;
86454   }
86455   {
86456     try {
86457       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
86458     } catch (std::out_of_range& e) {
86459       {
86460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86461       };
86462     } catch (std::exception& e) {
86463       {
86464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86465       };
86466     } catch (Dali::DaliException e) {
86467       {
86468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86469       };
86470     } catch (...) {
86471       {
86472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86473       };
86474     }
86475   }
86476
86477 }
86478
86479
86480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
86481   void * jresult ;
86482   Dali::Toolkit::VisualFactory result;
86483
86484   {
86485     try {
86486       result = Dali::Toolkit::VisualFactory::Get();
86487     } catch (std::out_of_range& e) {
86488       {
86489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86490       };
86491     } catch (std::exception& e) {
86492       {
86493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86494       };
86495     } catch (Dali::DaliException e) {
86496       {
86497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86498       };
86499     } catch (...) {
86500       {
86501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86502       };
86503     }
86504   }
86505
86506   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86507   return jresult;
86508 }
86509
86510
86511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86512   void * jresult ;
86513   Dali::Toolkit::VisualFactory *result = 0 ;
86514
86515   {
86516     try {
86517       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86518     } catch (std::out_of_range& e) {
86519       {
86520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86521       };
86522     } catch (std::exception& e) {
86523       {
86524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86525       };
86526     } catch (Dali::DaliException e) {
86527       {
86528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86529       };
86530     } catch (...) {
86531       {
86532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86533       };
86534     }
86535   }
86536
86537   jresult = (void *)result;
86538   return jresult;
86539 }
86540
86541
86542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86543   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86544
86545   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86546   {
86547     try {
86548       delete arg1;
86549     } catch (std::out_of_range& e) {
86550       {
86551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86552       };
86553     } catch (std::exception& e) {
86554       {
86555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86556       };
86557     } catch (Dali::DaliException e) {
86558       {
86559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86560       };
86561     } catch (...) {
86562       {
86563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86564       };
86565     }
86566   }
86567
86568 }
86569
86570
86571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86572   void * jresult ;
86573   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86574   Dali::Toolkit::VisualFactory *result = 0 ;
86575
86576   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86577   if (!arg1) {
86578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86579     return 0;
86580   }
86581   {
86582     try {
86583       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86584     } catch (std::out_of_range& e) {
86585       {
86586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86587       };
86588     } catch (std::exception& e) {
86589       {
86590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86591       };
86592     } catch (Dali::DaliException e) {
86593       {
86594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86595       };
86596     } catch (...) {
86597       {
86598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86599       };
86600     }
86601   }
86602
86603   jresult = (void *)result;
86604   return jresult;
86605 }
86606
86607
86608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86609   void * jresult ;
86610   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86611   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86612   Dali::Toolkit::VisualFactory *result = 0 ;
86613
86614   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86615   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86616   if (!arg2) {
86617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86618     return 0;
86619   }
86620   {
86621     try {
86622       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86623     } catch (std::out_of_range& e) {
86624       {
86625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86626       };
86627     } catch (std::exception& e) {
86628       {
86629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86630       };
86631     } catch (Dali::DaliException e) {
86632       {
86633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86634       };
86635     } catch (...) {
86636       {
86637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86638       };
86639     }
86640   }
86641
86642   jresult = (void *)result;
86643   return jresult;
86644 }
86645
86646
86647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86648   void * jresult ;
86649   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86650   Dali::Property::Map *arg2 = 0 ;
86651   Dali::Toolkit::Visual::Base result;
86652
86653   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86654   arg2 = (Dali::Property::Map *)jarg2;
86655   if (!arg2) {
86656     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86657     return 0;
86658   }
86659   {
86660     try {
86661       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86662     } catch (std::out_of_range& e) {
86663       {
86664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86665       };
86666     } catch (std::exception& e) {
86667       {
86668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86669       };
86670     } catch (Dali::DaliException e) {
86671       {
86672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86673       };
86674     } catch (...) {
86675       {
86676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86677       };
86678     }
86679   }
86680
86681   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86682   return jresult;
86683 }
86684
86685
86686 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86687   void * jresult ;
86688   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86689   std::string *arg2 = 0 ;
86690   Dali::ImageDimensions arg3 ;
86691   Dali::ImageDimensions *argp3 ;
86692   Dali::Toolkit::Visual::Base result;
86693
86694   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86695   if (!jarg2) {
86696     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86697     return 0;
86698   }
86699   std::string arg2_str(jarg2);
86700   arg2 = &arg2_str;
86701   argp3 = (Dali::ImageDimensions *)jarg3;
86702   if (!argp3) {
86703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86704     return 0;
86705   }
86706   arg3 = *argp3;
86707   {
86708     try {
86709       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86710     } catch (std::out_of_range& e) {
86711       {
86712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86713       };
86714     } catch (std::exception& e) {
86715       {
86716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86717       };
86718     } catch (Dali::DaliException e) {
86719       {
86720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86721       };
86722     } catch (...) {
86723       {
86724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86725       };
86726     }
86727   }
86728
86729   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86730
86731   //argout typemap for const std::string&
86732
86733   return jresult;
86734 }
86735
86736
86737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86738   void * jresult ;
86739   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86740
86741   {
86742     try {
86743       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86744     } catch (std::out_of_range& e) {
86745       {
86746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86747       };
86748     } catch (std::exception& e) {
86749       {
86750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86751       };
86752     } catch (Dali::DaliException e) {
86753       {
86754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86755       };
86756     } catch (...) {
86757       {
86758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86759       };
86760     }
86761   }
86762
86763   jresult = (void *)result;
86764   return jresult;
86765 }
86766
86767
86768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86769   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86770
86771   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86772   {
86773     try {
86774       delete arg1;
86775     } catch (std::out_of_range& e) {
86776       {
86777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86778       };
86779     } catch (std::exception& e) {
86780       {
86781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86782       };
86783     } catch (Dali::DaliException e) {
86784       {
86785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86786       };
86787     } catch (...) {
86788       {
86789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86790       };
86791     }
86792   }
86793
86794 }
86795
86796
86797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86798   void * jresult ;
86799   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86800   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86801
86802   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86803   if (!arg1) {
86804     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86805     return 0;
86806   }
86807   {
86808     try {
86809       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86810     } catch (std::out_of_range& e) {
86811       {
86812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86813       };
86814     } catch (std::exception& e) {
86815       {
86816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86817       };
86818     } catch (Dali::DaliException e) {
86819       {
86820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86821       };
86822     } catch (...) {
86823       {
86824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86825       };
86826     }
86827   }
86828
86829   jresult = (void *)result;
86830   return jresult;
86831 }
86832
86833
86834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86835   void * jresult ;
86836   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86837   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86838   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86839
86840   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86841   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86842   if (!arg2) {
86843     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86844     return 0;
86845   }
86846   {
86847     try {
86848       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86849     } catch (std::out_of_range& e) {
86850       {
86851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86852       };
86853     } catch (std::exception& e) {
86854       {
86855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86856       };
86857     } catch (Dali::DaliException e) {
86858       {
86859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86860       };
86861     } catch (...) {
86862       {
86863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86864       };
86865     }
86866   }
86867
86868   jresult = (void *)result;
86869   return jresult;
86870 }
86871
86872
86873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86874   void * jresult ;
86875   Dali::Toolkit::AsyncImageLoader result;
86876
86877   {
86878     try {
86879       result = Dali::Toolkit::AsyncImageLoader::New();
86880     } catch (std::out_of_range& e) {
86881       {
86882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86883       };
86884     } catch (std::exception& e) {
86885       {
86886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86887       };
86888     } catch (Dali::DaliException e) {
86889       {
86890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86891       };
86892     } catch (...) {
86893       {
86894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86895       };
86896     }
86897   }
86898
86899   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86900   return jresult;
86901 }
86902
86903
86904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86905   void * jresult ;
86906   Dali::BaseHandle arg1 ;
86907   Dali::BaseHandle *argp1 ;
86908   Dali::Toolkit::AsyncImageLoader result;
86909
86910   argp1 = (Dali::BaseHandle *)jarg1;
86911   if (!argp1) {
86912     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86913     return 0;
86914   }
86915   arg1 = *argp1;
86916   {
86917     try {
86918       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86919     } catch (std::out_of_range& e) {
86920       {
86921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86922       };
86923     } catch (std::exception& e) {
86924       {
86925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86926       };
86927     } catch (Dali::DaliException e) {
86928       {
86929         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86930       };
86931     } catch (...) {
86932       {
86933         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86934       };
86935     }
86936   }
86937
86938   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86939   return jresult;
86940 }
86941
86942
86943 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86944   unsigned int jresult ;
86945   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86946   std::string *arg2 = 0 ;
86947   uint32_t result;
86948
86949   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86950   if (!jarg2) {
86951     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86952     return 0;
86953   }
86954   std::string arg2_str(jarg2);
86955   arg2 = &arg2_str;
86956   {
86957     try {
86958       result = (arg1)->Load((std::string const &)*arg2);
86959     } catch (std::out_of_range& e) {
86960       {
86961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86962       };
86963     } catch (std::exception& e) {
86964       {
86965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86966       };
86967     } catch (Dali::DaliException e) {
86968       {
86969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86970       };
86971     } catch (...) {
86972       {
86973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86974       };
86975     }
86976   }
86977
86978   jresult = result;
86979
86980   //argout typemap for const std::string&
86981
86982   return jresult;
86983 }
86984
86985
86986 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86987   unsigned int jresult ;
86988   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86989   std::string *arg2 = 0 ;
86990   Dali::ImageDimensions arg3 ;
86991   Dali::ImageDimensions *argp3 ;
86992   uint32_t result;
86993
86994   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86995   if (!jarg2) {
86996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86997     return 0;
86998   }
86999   std::string arg2_str(jarg2);
87000   arg2 = &arg2_str;
87001   argp3 = (Dali::ImageDimensions *)jarg3;
87002   if (!argp3) {
87003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87004     return 0;
87005   }
87006   arg3 = *argp3;
87007   {
87008     try {
87009       result = (arg1)->Load((std::string const &)*arg2,arg3);
87010     } catch (std::out_of_range& e) {
87011       {
87012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87013       };
87014     } catch (std::exception& e) {
87015       {
87016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87017       };
87018     } catch (Dali::DaliException e) {
87019       {
87020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87021       };
87022     } catch (...) {
87023       {
87024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87025       };
87026     }
87027   }
87028
87029   jresult = result;
87030
87031   //argout typemap for const std::string&
87032
87033   return jresult;
87034 }
87035
87036
87037 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
87038   unsigned int jresult ;
87039   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87040   std::string *arg2 = 0 ;
87041   Dali::ImageDimensions arg3 ;
87042   Dali::FittingMode::Type arg4 ;
87043   Dali::SamplingMode::Type arg5 ;
87044   bool arg6 ;
87045   Dali::ImageDimensions *argp3 ;
87046   uint32_t result;
87047
87048   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87049   if (!jarg2) {
87050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87051     return 0;
87052   }
87053   std::string arg2_str(jarg2);
87054   arg2 = &arg2_str;
87055   argp3 = (Dali::ImageDimensions *)jarg3;
87056   if (!argp3) {
87057     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87058     return 0;
87059   }
87060   arg3 = *argp3;
87061   arg4 = (Dali::FittingMode::Type)jarg4;
87062   arg5 = (Dali::SamplingMode::Type)jarg5;
87063   arg6 = jarg6 ? true : false;
87064   {
87065     try {
87066       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
87067     } catch (std::out_of_range& e) {
87068       {
87069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87070       };
87071     } catch (std::exception& e) {
87072       {
87073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87074       };
87075     } catch (Dali::DaliException e) {
87076       {
87077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87078       };
87079     } catch (...) {
87080       {
87081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87082       };
87083     }
87084   }
87085
87086   jresult = result;
87087
87088   //argout typemap for const std::string&
87089
87090   return jresult;
87091 }
87092
87093
87094 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
87095   unsigned int jresult ;
87096   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87097   uint32_t arg2 ;
87098   bool result;
87099
87100   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87101   arg2 = (uint32_t)jarg2;
87102   {
87103     try {
87104       result = (bool)(arg1)->Cancel(arg2);
87105     } catch (std::out_of_range& e) {
87106       {
87107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87108       };
87109     } catch (std::exception& e) {
87110       {
87111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87112       };
87113     } catch (Dali::DaliException e) {
87114       {
87115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87116       };
87117     } catch (...) {
87118       {
87119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87120       };
87121     }
87122   }
87123
87124   jresult = result;
87125   return jresult;
87126 }
87127
87128
87129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
87130   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87131
87132   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87133   {
87134     try {
87135       (arg1)->CancelAll();
87136     } catch (std::out_of_range& e) {
87137       {
87138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87139       };
87140     } catch (std::exception& e) {
87141       {
87142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87143       };
87144     } catch (Dali::DaliException e) {
87145       {
87146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87147       };
87148     } catch (...) {
87149       {
87150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87151       };
87152     }
87153   }
87154
87155 }
87156
87157
87158 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
87159   void * jresult ;
87160   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
87161   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
87162
87163   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
87164   {
87165     try {
87166       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
87167     } catch (std::out_of_range& e) {
87168       {
87169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87170       };
87171     } catch (std::exception& e) {
87172       {
87173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87174       };
87175     } catch (Dali::DaliException e) {
87176       {
87177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87178       };
87179     } catch (...) {
87180       {
87181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87182       };
87183     }
87184   }
87185
87186   jresult = (void *)result;
87187   return jresult;
87188 }
87189
87190
87191 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
87192   void * jresult ;
87193   std::string *arg1 = 0 ;
87194   Dali::PixelData result;
87195
87196   if (!jarg1) {
87197     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87198     return 0;
87199   }
87200   std::string arg1_str(jarg1);
87201   arg1 = &arg1_str;
87202   {
87203     try {
87204       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
87205     } catch (std::out_of_range& e) {
87206       {
87207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87208       };
87209     } catch (std::exception& e) {
87210       {
87211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87212       };
87213     } catch (Dali::DaliException e) {
87214       {
87215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87216       };
87217     } catch (...) {
87218       {
87219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87220       };
87221     }
87222   }
87223
87224   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87225
87226   //argout typemap for const std::string&
87227
87228   return jresult;
87229 }
87230
87231
87232 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
87233   void * jresult ;
87234   std::string *arg1 = 0 ;
87235   Dali::ImageDimensions arg2 ;
87236   Dali::ImageDimensions *argp2 ;
87237   Dali::PixelData result;
87238
87239   if (!jarg1) {
87240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87241     return 0;
87242   }
87243   std::string arg1_str(jarg1);
87244   arg1 = &arg1_str;
87245   argp2 = (Dali::ImageDimensions *)jarg2;
87246   if (!argp2) {
87247     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87248     return 0;
87249   }
87250   arg2 = *argp2;
87251   {
87252     try {
87253       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
87254     } catch (std::out_of_range& e) {
87255       {
87256         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87257       };
87258     } catch (std::exception& e) {
87259       {
87260         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87261       };
87262     } catch (Dali::DaliException e) {
87263       {
87264         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87265       };
87266     } catch (...) {
87267       {
87268         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87269       };
87270     }
87271   }
87272
87273   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87274
87275   //argout typemap for const std::string&
87276
87277   return jresult;
87278 }
87279
87280
87281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
87282   void * jresult ;
87283   std::string *arg1 = 0 ;
87284   Dali::ImageDimensions arg2 ;
87285   Dali::FittingMode::Type arg3 ;
87286   Dali::SamplingMode::Type arg4 ;
87287   bool arg5 ;
87288   Dali::ImageDimensions *argp2 ;
87289   Dali::PixelData result;
87290
87291   if (!jarg1) {
87292     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
87293     return 0;
87294   }
87295   std::string arg1_str(jarg1);
87296   arg1 = &arg1_str;
87297   argp2 = (Dali::ImageDimensions *)jarg2;
87298   if (!argp2) {
87299     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
87300     return 0;
87301   }
87302   arg2 = *argp2;
87303   arg3 = (Dali::FittingMode::Type)jarg3;
87304   arg4 = (Dali::SamplingMode::Type)jarg4;
87305   arg5 = jarg5 ? true : false;
87306   {
87307     try {
87308       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
87309     } catch (std::out_of_range& e) {
87310       {
87311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87312       };
87313     } catch (std::exception& e) {
87314       {
87315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87316       };
87317     } catch (Dali::DaliException e) {
87318       {
87319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87320       };
87321     } catch (...) {
87322       {
87323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87324       };
87325     }
87326   }
87327
87328   jresult = new Dali::PixelData((const Dali::PixelData &)result);
87329
87330   //argout typemap for const std::string&
87331
87332   return jresult;
87333 }
87334
87335
87336 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
87337   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87338
87339   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87340   {
87341     try {
87342       delete arg1;
87343     } catch (std::out_of_range& e) {
87344       {
87345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87346       };
87347     } catch (std::exception& e) {
87348       {
87349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87350       };
87351     } catch (Dali::DaliException e) {
87352       {
87353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87354       };
87355     } catch (...) {
87356       {
87357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87358       };
87359     }
87360   }
87361
87362 }
87363
87364
87365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
87366   void * jresult ;
87367   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
87368   Dali::Actor arg2 ;
87369   Dali::Actor arg3 ;
87370   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
87371   Dali::Actor *argp2 ;
87372   Dali::Actor *argp3 ;
87373   Dali::Actor result;
87374
87375   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
87376   argp2 = (Dali::Actor *)jarg2;
87377   if (!argp2) {
87378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87379     return 0;
87380   }
87381   arg2 = *argp2;
87382   argp3 = (Dali::Actor *)jarg3;
87383   if (!argp3) {
87384     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
87385     return 0;
87386   }
87387   arg3 = *argp3;
87388   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
87389   {
87390     try {
87391       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
87392     } catch (std::out_of_range& e) {
87393       {
87394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87395       };
87396     } catch (std::exception& e) {
87397       {
87398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87399       };
87400     } catch (Dali::DaliException e) {
87401       {
87402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87403       };
87404     } catch (...) {
87405       {
87406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87407       };
87408     }
87409   }
87410
87411   jresult = new Dali::Actor((const Dali::Actor &)result);
87412   return jresult;
87413 }
87414
87415
87416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
87417   void * jresult ;
87418   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
87419
87420   {
87421     try {
87422       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
87423     } catch (std::out_of_range& e) {
87424       {
87425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87426       };
87427     } catch (std::exception& e) {
87428       {
87429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87430       };
87431     } catch (Dali::DaliException e) {
87432       {
87433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87434       };
87435     } catch (...) {
87436       {
87437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87438       };
87439     }
87440   }
87441
87442   jresult = (void *)result;
87443   return jresult;
87444 }
87445
87446
87447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
87448   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
87449   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
87450   if (director) {
87451     director->swig_connect_director(callback0);
87452   }
87453 }
87454
87455
87456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
87457   KeyboardFocusManager arg1 ;
87458   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
87459   KeyboardFocusManager *argp1 ;
87460
87461   argp1 = (KeyboardFocusManager *)jarg1;
87462   if (!argp1) {
87463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
87464     return ;
87465   }
87466   arg1 = *argp1;
87467   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
87468   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
87469   {
87470     try {
87471       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
87472     } catch (std::out_of_range& e) {
87473       {
87474         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87475       };
87476     } catch (std::exception& e) {
87477       {
87478         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87479       };
87480     } catch (Dali::DaliException e) {
87481       {
87482         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87483       };
87484     } catch (...) {
87485       {
87486         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87487       };
87488     }
87489   }
87490
87491 }
87492
87493
87494 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
87495   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87496
87497   arg1 = (std::vector< unsigned int > *)jarg1;
87498   {
87499     try {
87500       (arg1)->clear();
87501     } catch (std::out_of_range& e) {
87502       {
87503         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87504       };
87505     } catch (std::exception& e) {
87506       {
87507         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87508       };
87509     } catch (Dali::DaliException e) {
87510       {
87511         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87512       };
87513     } catch (...) {
87514       {
87515         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87516       };
87517     }
87518   }
87519
87520 }
87521
87522
87523 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87524   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87525   unsigned int *arg2 = 0 ;
87526   unsigned int temp2 ;
87527
87528   arg1 = (std::vector< unsigned int > *)jarg1;
87529   temp2 = (unsigned int)jarg2;
87530   arg2 = &temp2;
87531   {
87532     try {
87533       (arg1)->push_back((unsigned int const &)*arg2);
87534     } catch (std::out_of_range& e) {
87535       {
87536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87537       };
87538     } catch (std::exception& e) {
87539       {
87540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87541       };
87542     } catch (Dali::DaliException e) {
87543       {
87544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87545       };
87546     } catch (...) {
87547       {
87548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87549       };
87550     }
87551   }
87552
87553 }
87554
87555
87556 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87557   unsigned long jresult ;
87558   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87559   std::vector< unsigned int >::size_type result;
87560
87561   arg1 = (std::vector< unsigned int > *)jarg1;
87562   {
87563     try {
87564       result = ((std::vector< unsigned int > const *)arg1)->size();
87565     } catch (std::out_of_range& e) {
87566       {
87567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87568       };
87569     } catch (std::exception& e) {
87570       {
87571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87572       };
87573     } catch (Dali::DaliException e) {
87574       {
87575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87576       };
87577     } catch (...) {
87578       {
87579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87580       };
87581     }
87582   }
87583
87584   jresult = (unsigned long)result;
87585   return jresult;
87586 }
87587
87588
87589 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87590   unsigned long jresult ;
87591   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87592   std::vector< unsigned int >::size_type result;
87593
87594   arg1 = (std::vector< unsigned int > *)jarg1;
87595   {
87596     try {
87597       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87598     } catch (std::out_of_range& e) {
87599       {
87600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87601       };
87602     } catch (std::exception& e) {
87603       {
87604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87605       };
87606     } catch (Dali::DaliException e) {
87607       {
87608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87609       };
87610     } catch (...) {
87611       {
87612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87613       };
87614     }
87615   }
87616
87617   jresult = (unsigned long)result;
87618   return jresult;
87619 }
87620
87621
87622 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87623   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87624   std::vector< unsigned int >::size_type arg2 ;
87625
87626   arg1 = (std::vector< unsigned int > *)jarg1;
87627   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87628   {
87629     try {
87630       (arg1)->reserve(arg2);
87631     } catch (std::out_of_range& e) {
87632       {
87633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87634       };
87635     } catch (std::exception& e) {
87636       {
87637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87638       };
87639     } catch (Dali::DaliException e) {
87640       {
87641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87642       };
87643     } catch (...) {
87644       {
87645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87646       };
87647     }
87648   }
87649
87650 }
87651
87652
87653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87654   void * jresult ;
87655   std::vector< unsigned int > *result = 0 ;
87656
87657   {
87658     try {
87659       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87660     } catch (std::out_of_range& e) {
87661       {
87662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87663       };
87664     } catch (std::exception& e) {
87665       {
87666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87667       };
87668     } catch (Dali::DaliException e) {
87669       {
87670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87671       };
87672     } catch (...) {
87673       {
87674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87675       };
87676     }
87677   }
87678
87679   jresult = (void *)result;
87680   return jresult;
87681 }
87682
87683
87684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87685   void * jresult ;
87686   std::vector< unsigned int > *arg1 = 0 ;
87687   std::vector< unsigned int > *result = 0 ;
87688
87689   arg1 = (std::vector< unsigned int > *)jarg1;
87690   if (!arg1) {
87691     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87692     return 0;
87693   }
87694   {
87695     try {
87696       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87697     } catch (std::out_of_range& e) {
87698       {
87699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87700       };
87701     } catch (std::exception& e) {
87702       {
87703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87704       };
87705     } catch (Dali::DaliException e) {
87706       {
87707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87708       };
87709     } catch (...) {
87710       {
87711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87712       };
87713     }
87714   }
87715
87716   jresult = (void *)result;
87717   return jresult;
87718 }
87719
87720
87721 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87722   void * jresult ;
87723   int arg1 ;
87724   std::vector< unsigned int > *result = 0 ;
87725
87726   arg1 = (int)jarg1;
87727   {
87728     try {
87729       try {
87730         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87731       }
87732       catch(std::out_of_range &_e) {
87733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87734         return 0;
87735       }
87736
87737     } catch (std::out_of_range& e) {
87738       {
87739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87740       };
87741     } catch (std::exception& e) {
87742       {
87743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87744       };
87745     } catch (Dali::DaliException e) {
87746       {
87747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87748       };
87749     } catch (...) {
87750       {
87751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87752       };
87753     }
87754   }
87755
87756   jresult = (void *)result;
87757   return jresult;
87758 }
87759
87760
87761 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87762   unsigned int jresult ;
87763   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87764   int arg2 ;
87765   unsigned int result;
87766
87767   arg1 = (std::vector< unsigned int > *)jarg1;
87768   arg2 = (int)jarg2;
87769   {
87770     try {
87771       try {
87772         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87773       }
87774       catch(std::out_of_range &_e) {
87775         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87776         return 0;
87777       }
87778
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 = result;
87799   return jresult;
87800 }
87801
87802
87803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87804   unsigned int jresult ;
87805   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87806   int arg2 ;
87807   unsigned int *result = 0 ;
87808
87809   arg1 = (std::vector< unsigned int > *)jarg1;
87810   arg2 = (int)jarg2;
87811   {
87812     try {
87813       try {
87814         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87815       }
87816       catch(std::out_of_range &_e) {
87817         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87818         return 0;
87819       }
87820
87821     } catch (std::out_of_range& e) {
87822       {
87823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87824       };
87825     } catch (std::exception& e) {
87826       {
87827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87828       };
87829     } catch (Dali::DaliException e) {
87830       {
87831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87832       };
87833     } catch (...) {
87834       {
87835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87836       };
87837     }
87838   }
87839
87840   jresult = *result;
87841   return jresult;
87842 }
87843
87844
87845 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87846   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87847   int arg2 ;
87848   unsigned int *arg3 = 0 ;
87849   unsigned int temp3 ;
87850
87851   arg1 = (std::vector< unsigned int > *)jarg1;
87852   arg2 = (int)jarg2;
87853   temp3 = (unsigned int)jarg3;
87854   arg3 = &temp3;
87855   {
87856     try {
87857       try {
87858         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87859       }
87860       catch(std::out_of_range &_e) {
87861         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87862         return ;
87863       }
87864
87865     } catch (std::out_of_range& e) {
87866       {
87867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87868       };
87869     } catch (std::exception& e) {
87870       {
87871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87872       };
87873     } catch (Dali::DaliException e) {
87874       {
87875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87876       };
87877     } catch (...) {
87878       {
87879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87880       };
87881     }
87882   }
87883
87884 }
87885
87886
87887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87888   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87889   std::vector< unsigned int > *arg2 = 0 ;
87890
87891   arg1 = (std::vector< unsigned int > *)jarg1;
87892   arg2 = (std::vector< unsigned int > *)jarg2;
87893   if (!arg2) {
87894     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87895     return ;
87896   }
87897   {
87898     try {
87899       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87900     } catch (std::out_of_range& e) {
87901       {
87902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87903       };
87904     } catch (std::exception& e) {
87905       {
87906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87907       };
87908     } catch (Dali::DaliException e) {
87909       {
87910         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87911       };
87912     } catch (...) {
87913       {
87914         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87915       };
87916     }
87917   }
87918
87919 }
87920
87921
87922 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87923   void * jresult ;
87924   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87925   int arg2 ;
87926   int arg3 ;
87927   std::vector< unsigned int > *result = 0 ;
87928
87929   arg1 = (std::vector< unsigned int > *)jarg1;
87930   arg2 = (int)jarg2;
87931   arg3 = (int)jarg3;
87932   {
87933     try {
87934       try {
87935         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87936       }
87937       catch(std::out_of_range &_e) {
87938         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87939         return 0;
87940       }
87941       catch(std::invalid_argument &_e) {
87942         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87943         return 0;
87944       }
87945
87946     } catch (std::out_of_range& e) {
87947       {
87948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87949       };
87950     } catch (std::exception& e) {
87951       {
87952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87953       };
87954     } catch (Dali::DaliException e) {
87955       {
87956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87957       };
87958     } catch (...) {
87959       {
87960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87961       };
87962     }
87963   }
87964
87965   jresult = (void *)result;
87966   return jresult;
87967 }
87968
87969
87970 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87971   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87972   int arg2 ;
87973   unsigned int *arg3 = 0 ;
87974   unsigned int temp3 ;
87975
87976   arg1 = (std::vector< unsigned int > *)jarg1;
87977   arg2 = (int)jarg2;
87978   temp3 = (unsigned int)jarg3;
87979   arg3 = &temp3;
87980   {
87981     try {
87982       try {
87983         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87984       }
87985       catch(std::out_of_range &_e) {
87986         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87987         return ;
87988       }
87989
87990     } catch (std::out_of_range& e) {
87991       {
87992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87993       };
87994     } catch (std::exception& e) {
87995       {
87996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87997       };
87998     } catch (Dali::DaliException e) {
87999       {
88000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88001       };
88002     } catch (...) {
88003       {
88004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88005       };
88006     }
88007   }
88008
88009 }
88010
88011
88012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88013   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88014   int arg2 ;
88015   std::vector< unsigned int > *arg3 = 0 ;
88016
88017   arg1 = (std::vector< unsigned int > *)jarg1;
88018   arg2 = (int)jarg2;
88019   arg3 = (std::vector< unsigned int > *)jarg3;
88020   if (!arg3) {
88021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88022     return ;
88023   }
88024   {
88025     try {
88026       try {
88027         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88028       }
88029       catch(std::out_of_range &_e) {
88030         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88031         return ;
88032       }
88033
88034     } catch (std::out_of_range& e) {
88035       {
88036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88037       };
88038     } catch (std::exception& e) {
88039       {
88040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88041       };
88042     } catch (Dali::DaliException e) {
88043       {
88044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88045       };
88046     } catch (...) {
88047       {
88048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88049       };
88050     }
88051   }
88052
88053 }
88054
88055
88056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
88057   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88058   int arg2 ;
88059
88060   arg1 = (std::vector< unsigned int > *)jarg1;
88061   arg2 = (int)jarg2;
88062   {
88063     try {
88064       try {
88065         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
88066       }
88067       catch(std::out_of_range &_e) {
88068         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88069         return ;
88070       }
88071
88072     } catch (std::out_of_range& e) {
88073       {
88074         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88075       };
88076     } catch (std::exception& e) {
88077       {
88078         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88079       };
88080     } catch (Dali::DaliException e) {
88081       {
88082         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88083       };
88084     } catch (...) {
88085       {
88086         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88087       };
88088     }
88089   }
88090
88091 }
88092
88093
88094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88095   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88096   int arg2 ;
88097   int arg3 ;
88098
88099   arg1 = (std::vector< unsigned int > *)jarg1;
88100   arg2 = (int)jarg2;
88101   arg3 = (int)jarg3;
88102   {
88103     try {
88104       try {
88105         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
88106       }
88107       catch(std::out_of_range &_e) {
88108         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88109         return ;
88110       }
88111       catch(std::invalid_argument &_e) {
88112         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88113         return ;
88114       }
88115
88116     } catch (std::out_of_range& e) {
88117       {
88118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88119       };
88120     } catch (std::exception& e) {
88121       {
88122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88123       };
88124     } catch (Dali::DaliException e) {
88125       {
88126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88127       };
88128     } catch (...) {
88129       {
88130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88131       };
88132     }
88133   }
88134
88135 }
88136
88137
88138 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
88139   void * jresult ;
88140   unsigned int *arg1 = 0 ;
88141   int arg2 ;
88142   unsigned int temp1 ;
88143   std::vector< unsigned int > *result = 0 ;
88144
88145   temp1 = (unsigned int)jarg1;
88146   arg1 = &temp1;
88147   arg2 = (int)jarg2;
88148   {
88149     try {
88150       try {
88151         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
88152       }
88153       catch(std::out_of_range &_e) {
88154         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88155         return 0;
88156       }
88157
88158     } catch (std::out_of_range& e) {
88159       {
88160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88161       };
88162     } catch (std::exception& e) {
88163       {
88164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88165       };
88166     } catch (Dali::DaliException e) {
88167       {
88168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88169       };
88170     } catch (...) {
88171       {
88172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88173       };
88174     }
88175   }
88176
88177   jresult = (void *)result;
88178   return jresult;
88179 }
88180
88181
88182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
88183   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88184
88185   arg1 = (std::vector< unsigned int > *)jarg1;
88186   {
88187     try {
88188       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
88189     } catch (std::out_of_range& e) {
88190       {
88191         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88192       };
88193     } catch (std::exception& e) {
88194       {
88195         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88196       };
88197     } catch (Dali::DaliException e) {
88198       {
88199         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88200       };
88201     } catch (...) {
88202       {
88203         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88204       };
88205     }
88206   }
88207
88208 }
88209
88210
88211 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88212   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88213   int arg2 ;
88214   int arg3 ;
88215
88216   arg1 = (std::vector< unsigned int > *)jarg1;
88217   arg2 = (int)jarg2;
88218   arg3 = (int)jarg3;
88219   {
88220     try {
88221       try {
88222         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88223       }
88224       catch(std::out_of_range &_e) {
88225         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88226         return ;
88227       }
88228       catch(std::invalid_argument &_e) {
88229         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88230         return ;
88231       }
88232
88233     } catch (std::out_of_range& e) {
88234       {
88235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88236       };
88237     } catch (std::exception& e) {
88238       {
88239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88240       };
88241     } catch (Dali::DaliException e) {
88242       {
88243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88244       };
88245     } catch (...) {
88246       {
88247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88248       };
88249     }
88250   }
88251
88252 }
88253
88254
88255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88256   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88257   int arg2 ;
88258   std::vector< unsigned int > *arg3 = 0 ;
88259
88260   arg1 = (std::vector< unsigned int > *)jarg1;
88261   arg2 = (int)jarg2;
88262   arg3 = (std::vector< unsigned int > *)jarg3;
88263   if (!arg3) {
88264     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
88265     return ;
88266   }
88267   {
88268     try {
88269       try {
88270         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
88271       }
88272       catch(std::out_of_range &_e) {
88273         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88274         return ;
88275       }
88276
88277     } catch (std::out_of_range& e) {
88278       {
88279         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88280       };
88281     } catch (std::exception& e) {
88282       {
88283         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88284       };
88285     } catch (Dali::DaliException e) {
88286       {
88287         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88288       };
88289     } catch (...) {
88290       {
88291         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88292       };
88293     }
88294   }
88295
88296 }
88297
88298
88299 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
88300   unsigned int jresult ;
88301   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88302   unsigned int *arg2 = 0 ;
88303   unsigned int temp2 ;
88304   bool result;
88305
88306   arg1 = (std::vector< unsigned int > *)jarg1;
88307   temp2 = (unsigned int)jarg2;
88308   arg2 = &temp2;
88309   {
88310     try {
88311       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
88312     } catch (std::out_of_range& e) {
88313       {
88314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88315       };
88316     } catch (std::exception& e) {
88317       {
88318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88319       };
88320     } catch (Dali::DaliException e) {
88321       {
88322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88323       };
88324     } catch (...) {
88325       {
88326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88327       };
88328     }
88329   }
88330
88331   jresult = result;
88332   return jresult;
88333 }
88334
88335
88336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
88337   int jresult ;
88338   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88339   unsigned int *arg2 = 0 ;
88340   unsigned int temp2 ;
88341   int result;
88342
88343   arg1 = (std::vector< unsigned int > *)jarg1;
88344   temp2 = (unsigned int)jarg2;
88345   arg2 = &temp2;
88346   {
88347     try {
88348       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
88349     } catch (std::out_of_range& e) {
88350       {
88351         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88352       };
88353     } catch (std::exception& e) {
88354       {
88355         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88356       };
88357     } catch (Dali::DaliException e) {
88358       {
88359         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88360       };
88361     } catch (...) {
88362       {
88363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88364       };
88365     }
88366   }
88367
88368   jresult = result;
88369   return jresult;
88370 }
88371
88372
88373 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
88374   int jresult ;
88375   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88376   unsigned int *arg2 = 0 ;
88377   unsigned int temp2 ;
88378   int result;
88379
88380   arg1 = (std::vector< unsigned int > *)jarg1;
88381   temp2 = (unsigned int)jarg2;
88382   arg2 = &temp2;
88383   {
88384     try {
88385       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
88386     } catch (std::out_of_range& e) {
88387       {
88388         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88389       };
88390     } catch (std::exception& e) {
88391       {
88392         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88393       };
88394     } catch (Dali::DaliException e) {
88395       {
88396         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88397       };
88398     } catch (...) {
88399       {
88400         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88401       };
88402     }
88403   }
88404
88405   jresult = result;
88406   return jresult;
88407 }
88408
88409
88410 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
88411   unsigned int jresult ;
88412   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88413   unsigned int *arg2 = 0 ;
88414   unsigned int temp2 ;
88415   bool result;
88416
88417   arg1 = (std::vector< unsigned int > *)jarg1;
88418   temp2 = (unsigned int)jarg2;
88419   arg2 = &temp2;
88420   {
88421     try {
88422       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
88423     } catch (std::out_of_range& e) {
88424       {
88425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88426       };
88427     } catch (std::exception& e) {
88428       {
88429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88430       };
88431     } catch (Dali::DaliException e) {
88432       {
88433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88434       };
88435     } catch (...) {
88436       {
88437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88438       };
88439     }
88440   }
88441
88442   jresult = result;
88443   return jresult;
88444 }
88445
88446
88447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
88448   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
88449
88450   arg1 = (std::vector< unsigned int > *)jarg1;
88451   {
88452     try {
88453       delete arg1;
88454     } catch (std::out_of_range& e) {
88455       {
88456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88457       };
88458     } catch (std::exception& e) {
88459       {
88460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88461       };
88462     } catch (Dali::DaliException e) {
88463       {
88464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88465       };
88466     } catch (...) {
88467       {
88468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88469       };
88470     }
88471   }
88472
88473 }
88474
88475
88476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
88477   void * jresult ;
88478   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88479
88480   {
88481     try {
88482       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
88483     } catch (std::out_of_range& e) {
88484       {
88485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88486       };
88487     } catch (std::exception& e) {
88488       {
88489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88490       };
88491     } catch (Dali::DaliException e) {
88492       {
88493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88494       };
88495     } catch (...) {
88496       {
88497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88498       };
88499     }
88500   }
88501
88502   jresult = (void *)result;
88503   return jresult;
88504 }
88505
88506
88507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88508   void * jresult ;
88509   unsigned int arg1 ;
88510   Dali::Actor arg2 ;
88511   Dali::Actor *argp2 ;
88512   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88513
88514   arg1 = (unsigned int)jarg1;
88515   argp2 = (Dali::Actor *)jarg2;
88516   if (!argp2) {
88517     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88518     return 0;
88519   }
88520   arg2 = *argp2;
88521   {
88522     try {
88523       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88524     } catch (std::out_of_range& e) {
88525       {
88526         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88527       };
88528     } catch (std::exception& e) {
88529       {
88530         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88531       };
88532     } catch (Dali::DaliException e) {
88533       {
88534         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88535       };
88536     } catch (...) {
88537       {
88538         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88539       };
88540     }
88541   }
88542
88543   jresult = (void *)result;
88544   return jresult;
88545 }
88546
88547
88548 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88549   void * jresult ;
88550   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88551   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88552
88553   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88554   if (!arg1) {
88555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88556     return 0;
88557   }
88558   {
88559     try {
88560       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88561     } catch (std::out_of_range& e) {
88562       {
88563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88564       };
88565     } catch (std::exception& e) {
88566       {
88567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88568       };
88569     } catch (Dali::DaliException e) {
88570       {
88571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88572       };
88573     } catch (...) {
88574       {
88575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88576       };
88577     }
88578   }
88579
88580   jresult = (void *)result;
88581   return jresult;
88582 }
88583
88584
88585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88586   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88587   unsigned int arg2 ;
88588
88589   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88590   arg2 = (unsigned int)jarg2;
88591   if (arg1) (arg1)->first = arg2;
88592 }
88593
88594
88595 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88596   unsigned int jresult ;
88597   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88598   unsigned int result;
88599
88600   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88601   result = (unsigned int) ((arg1)->first);
88602   jresult = result;
88603   return jresult;
88604 }
88605
88606
88607 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88608   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88609   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88610
88611   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88612   arg2 = (Dali::Actor *)jarg2;
88613   if (arg1) (arg1)->second = *arg2;
88614 }
88615
88616
88617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88618   void * jresult ;
88619   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88620   Dali::Actor *result = 0 ;
88621
88622   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88623   result = (Dali::Actor *)& ((arg1)->second);
88624   jresult = (void *)result;
88625   return jresult;
88626 }
88627
88628
88629 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88630   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88631
88632   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88633   {
88634     try {
88635       delete arg1;
88636     } catch (std::out_of_range& e) {
88637       {
88638         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88639       };
88640     } catch (std::exception& e) {
88641       {
88642         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88643       };
88644     } catch (Dali::DaliException e) {
88645       {
88646         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88647       };
88648     } catch (...) {
88649       {
88650         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88651       };
88652     }
88653   }
88654
88655 }
88656
88657
88658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88659   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88660
88661   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88662   {
88663     try {
88664       (arg1)->clear();
88665     } catch (std::out_of_range& e) {
88666       {
88667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88668       };
88669     } catch (std::exception& e) {
88670       {
88671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88672       };
88673     } catch (Dali::DaliException e) {
88674       {
88675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88676       };
88677     } catch (...) {
88678       {
88679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88680       };
88681     }
88682   }
88683
88684 }
88685
88686
88687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88688   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88689   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88690
88691   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88692   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88693   if (!arg2) {
88694     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88695     return ;
88696   }
88697   {
88698     try {
88699       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88700     } catch (std::out_of_range& e) {
88701       {
88702         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88703       };
88704     } catch (std::exception& e) {
88705       {
88706         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88707       };
88708     } catch (Dali::DaliException e) {
88709       {
88710         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88711       };
88712     } catch (...) {
88713       {
88714         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88715       };
88716     }
88717   }
88718
88719 }
88720
88721
88722 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88723   unsigned long jresult ;
88724   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88725   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88726
88727   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88728   {
88729     try {
88730       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88731     } catch (std::out_of_range& e) {
88732       {
88733         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88734       };
88735     } catch (std::exception& e) {
88736       {
88737         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88738       };
88739     } catch (Dali::DaliException e) {
88740       {
88741         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88742       };
88743     } catch (...) {
88744       {
88745         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88746       };
88747     }
88748   }
88749
88750   jresult = (unsigned long)result;
88751   return jresult;
88752 }
88753
88754
88755 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88756   unsigned long jresult ;
88757   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88758   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88759
88760   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88761   {
88762     try {
88763       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88764     } catch (std::out_of_range& e) {
88765       {
88766         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88767       };
88768     } catch (std::exception& e) {
88769       {
88770         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88771       };
88772     } catch (Dali::DaliException e) {
88773       {
88774         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88775       };
88776     } catch (...) {
88777       {
88778         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88779       };
88780     }
88781   }
88782
88783   jresult = (unsigned long)result;
88784   return jresult;
88785 }
88786
88787
88788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88789   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88790   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88791
88792   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88793   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88794   {
88795     try {
88796       (arg1)->reserve(arg2);
88797     } catch (std::out_of_range& e) {
88798       {
88799         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88800       };
88801     } catch (std::exception& e) {
88802       {
88803         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88804       };
88805     } catch (Dali::DaliException e) {
88806       {
88807         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88808       };
88809     } catch (...) {
88810       {
88811         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88812       };
88813     }
88814   }
88815
88816 }
88817
88818
88819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88820   void * jresult ;
88821   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88822
88823   {
88824     try {
88825       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88826     } catch (std::out_of_range& e) {
88827       {
88828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88829       };
88830     } catch (std::exception& e) {
88831       {
88832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88833       };
88834     } catch (Dali::DaliException e) {
88835       {
88836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88837       };
88838     } catch (...) {
88839       {
88840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88841       };
88842     }
88843   }
88844
88845   jresult = (void *)result;
88846   return jresult;
88847 }
88848
88849
88850 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88851   void * jresult ;
88852   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88853   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88854
88855   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88856   if (!arg1) {
88857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88858     return 0;
88859   }
88860   {
88861     try {
88862       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);
88863     } catch (std::out_of_range& e) {
88864       {
88865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88866       };
88867     } catch (std::exception& e) {
88868       {
88869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88870       };
88871     } catch (Dali::DaliException e) {
88872       {
88873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88874       };
88875     } catch (...) {
88876       {
88877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88878       };
88879     }
88880   }
88881
88882   jresult = (void *)result;
88883   return jresult;
88884 }
88885
88886
88887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88888   void * jresult ;
88889   int arg1 ;
88890   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88891
88892   arg1 = (int)jarg1;
88893   {
88894     try {
88895       try {
88896         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);
88897       }
88898       catch(std::out_of_range &_e) {
88899         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88900         return 0;
88901       }
88902
88903     } catch (std::out_of_range& e) {
88904       {
88905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88906       };
88907     } catch (std::exception& e) {
88908       {
88909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88910       };
88911     } catch (Dali::DaliException e) {
88912       {
88913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88914       };
88915     } catch (...) {
88916       {
88917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88918       };
88919     }
88920   }
88921
88922   jresult = (void *)result;
88923   return jresult;
88924 }
88925
88926
88927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88928   void * jresult ;
88929   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88930   int arg2 ;
88931   std::pair< unsigned int,Dali::Actor > result;
88932
88933   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88934   arg2 = (int)jarg2;
88935   {
88936     try {
88937       try {
88938         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88939       }
88940       catch(std::out_of_range &_e) {
88941         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88942         return 0;
88943       }
88944
88945     } catch (std::out_of_range& e) {
88946       {
88947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88948       };
88949     } catch (std::exception& e) {
88950       {
88951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88952       };
88953     } catch (Dali::DaliException e) {
88954       {
88955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88956       };
88957     } catch (...) {
88958       {
88959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88960       };
88961     }
88962   }
88963
88964   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88965   return jresult;
88966 }
88967
88968
88969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88970   void * jresult ;
88971   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88972   int arg2 ;
88973   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88974
88975   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88976   arg2 = (int)jarg2;
88977   {
88978     try {
88979       try {
88980         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88981       }
88982       catch(std::out_of_range &_e) {
88983         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88984         return 0;
88985       }
88986
88987     } catch (std::out_of_range& e) {
88988       {
88989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88990       };
88991     } catch (std::exception& e) {
88992       {
88993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88994       };
88995     } catch (Dali::DaliException e) {
88996       {
88997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88998       };
88999     } catch (...) {
89000       {
89001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89002       };
89003     }
89004   }
89005
89006   jresult = (void *)result;
89007   return jresult;
89008 }
89009
89010
89011 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89012   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89013   int arg2 ;
89014   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
89015
89016   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89017   arg2 = (int)jarg2;
89018   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89019   if (!arg3) {
89020     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89021     return ;
89022   }
89023   {
89024     try {
89025       try {
89026         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);
89027       }
89028       catch(std::out_of_range &_e) {
89029         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89030         return ;
89031       }
89032
89033     } catch (std::out_of_range& e) {
89034       {
89035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89036       };
89037     } catch (std::exception& e) {
89038       {
89039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89040       };
89041     } catch (Dali::DaliException e) {
89042       {
89043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89044       };
89045     } catch (...) {
89046       {
89047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89048       };
89049     }
89050   }
89051
89052 }
89053
89054
89055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
89056   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89057   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
89058
89059   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89060   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
89061   if (!arg2) {
89062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89063     return ;
89064   }
89065   {
89066     try {
89067       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);
89068     } catch (std::out_of_range& e) {
89069       {
89070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89071       };
89072     } catch (std::exception& e) {
89073       {
89074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89075       };
89076     } catch (Dali::DaliException e) {
89077       {
89078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89079       };
89080     } catch (...) {
89081       {
89082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89083       };
89084     }
89085   }
89086
89087 }
89088
89089
89090 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89091   void * jresult ;
89092   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89093   int arg2 ;
89094   int arg3 ;
89095   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89096
89097   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89098   arg2 = (int)jarg2;
89099   arg3 = (int)jarg3;
89100   {
89101     try {
89102       try {
89103         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);
89104       }
89105       catch(std::out_of_range &_e) {
89106         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89107         return 0;
89108       }
89109       catch(std::invalid_argument &_e) {
89110         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89111         return 0;
89112       }
89113
89114     } catch (std::out_of_range& e) {
89115       {
89116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89117       };
89118     } catch (std::exception& e) {
89119       {
89120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89121       };
89122     } catch (Dali::DaliException e) {
89123       {
89124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89125       };
89126     } catch (...) {
89127       {
89128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89129       };
89130     }
89131   }
89132
89133   jresult = (void *)result;
89134   return jresult;
89135 }
89136
89137
89138 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89139   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89140   int arg2 ;
89141   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
89142
89143   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89144   arg2 = (int)jarg2;
89145   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
89146   if (!arg3) {
89147     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89148     return ;
89149   }
89150   {
89151     try {
89152       try {
89153         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);
89154       }
89155       catch(std::out_of_range &_e) {
89156         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89157         return ;
89158       }
89159
89160     } catch (std::out_of_range& e) {
89161       {
89162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89163       };
89164     } catch (std::exception& e) {
89165       {
89166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89167       };
89168     } catch (Dali::DaliException e) {
89169       {
89170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89171       };
89172     } catch (...) {
89173       {
89174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89175       };
89176     }
89177   }
89178
89179 }
89180
89181
89182 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89183   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89184   int arg2 ;
89185   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89186
89187   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89188   arg2 = (int)jarg2;
89189   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89190   if (!arg3) {
89191     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89192     return ;
89193   }
89194   {
89195     try {
89196       try {
89197         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);
89198       }
89199       catch(std::out_of_range &_e) {
89200         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89201         return ;
89202       }
89203
89204     } catch (std::out_of_range& e) {
89205       {
89206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89207       };
89208     } catch (std::exception& e) {
89209       {
89210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89211       };
89212     } catch (Dali::DaliException e) {
89213       {
89214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89215       };
89216     } catch (...) {
89217       {
89218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89219       };
89220     }
89221   }
89222
89223 }
89224
89225
89226 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
89227   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89228   int arg2 ;
89229
89230   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89231   arg2 = (int)jarg2;
89232   {
89233     try {
89234       try {
89235         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
89236       }
89237       catch(std::out_of_range &_e) {
89238         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89239         return ;
89240       }
89241
89242     } catch (std::out_of_range& e) {
89243       {
89244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89245       };
89246     } catch (std::exception& e) {
89247       {
89248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89249       };
89250     } catch (Dali::DaliException e) {
89251       {
89252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89253       };
89254     } catch (...) {
89255       {
89256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89257       };
89258     }
89259   }
89260
89261 }
89262
89263
89264 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89265   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89266   int arg2 ;
89267   int arg3 ;
89268
89269   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89270   arg2 = (int)jarg2;
89271   arg3 = (int)jarg3;
89272   {
89273     try {
89274       try {
89275         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
89276       }
89277       catch(std::out_of_range &_e) {
89278         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89279         return ;
89280       }
89281       catch(std::invalid_argument &_e) {
89282         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89283         return ;
89284       }
89285
89286     } catch (std::out_of_range& e) {
89287       {
89288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89289       };
89290     } catch (std::exception& e) {
89291       {
89292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89293       };
89294     } catch (Dali::DaliException e) {
89295       {
89296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89297       };
89298     } catch (...) {
89299       {
89300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89301       };
89302     }
89303   }
89304
89305 }
89306
89307
89308 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
89309   void * jresult ;
89310   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
89311   int arg2 ;
89312   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
89313
89314   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
89315   if (!arg1) {
89316     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
89317     return 0;
89318   }
89319   arg2 = (int)jarg2;
89320   {
89321     try {
89322       try {
89323         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);
89324       }
89325       catch(std::out_of_range &_e) {
89326         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89327         return 0;
89328       }
89329
89330     } catch (std::out_of_range& e) {
89331       {
89332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89333       };
89334     } catch (std::exception& e) {
89335       {
89336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89337       };
89338     } catch (Dali::DaliException e) {
89339       {
89340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89341       };
89342     } catch (...) {
89343       {
89344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89345       };
89346     }
89347   }
89348
89349   jresult = (void *)result;
89350   return jresult;
89351 }
89352
89353
89354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
89355   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89356
89357   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89358   {
89359     try {
89360       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
89361     } catch (std::out_of_range& e) {
89362       {
89363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89364       };
89365     } catch (std::exception& e) {
89366       {
89367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89368       };
89369     } catch (Dali::DaliException e) {
89370       {
89371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89372       };
89373     } catch (...) {
89374       {
89375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89376       };
89377     }
89378   }
89379
89380 }
89381
89382
89383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89384   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89385   int arg2 ;
89386   int arg3 ;
89387
89388   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89389   arg2 = (int)jarg2;
89390   arg3 = (int)jarg3;
89391   {
89392     try {
89393       try {
89394         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89395       }
89396       catch(std::out_of_range &_e) {
89397         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89398         return ;
89399       }
89400       catch(std::invalid_argument &_e) {
89401         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89402         return ;
89403       }
89404
89405     } catch (std::out_of_range& e) {
89406       {
89407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89408       };
89409     } catch (std::exception& e) {
89410       {
89411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89412       };
89413     } catch (Dali::DaliException e) {
89414       {
89415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89416       };
89417     } catch (...) {
89418       {
89419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89420       };
89421     }
89422   }
89423
89424 }
89425
89426
89427 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89428   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89429   int arg2 ;
89430   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
89431
89432   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89433   arg2 = (int)jarg2;
89434   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
89435   if (!arg3) {
89436     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
89437     return ;
89438   }
89439   {
89440     try {
89441       try {
89442         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);
89443       }
89444       catch(std::out_of_range &_e) {
89445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89446         return ;
89447       }
89448
89449     } catch (std::out_of_range& e) {
89450       {
89451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89452       };
89453     } catch (std::exception& e) {
89454       {
89455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89456       };
89457     } catch (Dali::DaliException e) {
89458       {
89459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89460       };
89461     } catch (...) {
89462       {
89463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89464       };
89465     }
89466   }
89467
89468 }
89469
89470
89471 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
89472   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
89473
89474   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
89475   {
89476     try {
89477       delete arg1;
89478     } catch (std::out_of_range& e) {
89479       {
89480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89481       };
89482     } catch (std::exception& e) {
89483       {
89484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89485       };
89486     } catch (Dali::DaliException e) {
89487       {
89488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89489       };
89490     } catch (...) {
89491       {
89492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89493       };
89494     }
89495   }
89496
89497 }
89498
89499
89500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89501   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89502
89503   arg1 = (std::vector< Dali::Actor > *)jarg1;
89504   {
89505     try {
89506       (arg1)->clear();
89507     } catch (std::out_of_range& e) {
89508       {
89509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89510       };
89511     } catch (std::exception& e) {
89512       {
89513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89514       };
89515     } catch (Dali::DaliException e) {
89516       {
89517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89518       };
89519     } catch (...) {
89520       {
89521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89522       };
89523     }
89524   }
89525
89526 }
89527
89528
89529 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89530   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89531   Dali::Actor *arg2 = 0 ;
89532
89533   arg1 = (std::vector< Dali::Actor > *)jarg1;
89534   arg2 = (Dali::Actor *)jarg2;
89535   if (!arg2) {
89536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89537     return ;
89538   }
89539   {
89540     try {
89541       (arg1)->push_back((Dali::Actor const &)*arg2);
89542     } catch (std::out_of_range& e) {
89543       {
89544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89545       };
89546     } catch (std::exception& e) {
89547       {
89548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89549       };
89550     } catch (Dali::DaliException e) {
89551       {
89552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89553       };
89554     } catch (...) {
89555       {
89556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89557       };
89558     }
89559   }
89560
89561 }
89562
89563
89564 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89565   unsigned long jresult ;
89566   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89567   std::vector< Dali::Actor >::size_type result;
89568
89569   arg1 = (std::vector< Dali::Actor > *)jarg1;
89570   {
89571     try {
89572       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89573     } catch (std::out_of_range& e) {
89574       {
89575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89576       };
89577     } catch (std::exception& e) {
89578       {
89579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89580       };
89581     } catch (Dali::DaliException e) {
89582       {
89583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89584       };
89585     } catch (...) {
89586       {
89587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89588       };
89589     }
89590   }
89591
89592   jresult = (unsigned long)result;
89593   return jresult;
89594 }
89595
89596
89597 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89598   unsigned long jresult ;
89599   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89600   std::vector< Dali::Actor >::size_type result;
89601
89602   arg1 = (std::vector< Dali::Actor > *)jarg1;
89603   {
89604     try {
89605       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89606     } catch (std::out_of_range& e) {
89607       {
89608         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89609       };
89610     } catch (std::exception& e) {
89611       {
89612         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89613       };
89614     } catch (Dali::DaliException e) {
89615       {
89616         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89617       };
89618     } catch (...) {
89619       {
89620         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89621       };
89622     }
89623   }
89624
89625   jresult = (unsigned long)result;
89626   return jresult;
89627 }
89628
89629
89630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89631   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89632   std::vector< Dali::Actor >::size_type arg2 ;
89633
89634   arg1 = (std::vector< Dali::Actor > *)jarg1;
89635   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89636   {
89637     try {
89638       (arg1)->reserve(arg2);
89639     } catch (std::out_of_range& e) {
89640       {
89641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89642       };
89643     } catch (std::exception& e) {
89644       {
89645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89646       };
89647     } catch (Dali::DaliException e) {
89648       {
89649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89650       };
89651     } catch (...) {
89652       {
89653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89654       };
89655     }
89656   }
89657
89658 }
89659
89660
89661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89662   void * jresult ;
89663   std::vector< Dali::Actor > *result = 0 ;
89664
89665   {
89666     try {
89667       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89668     } catch (std::out_of_range& e) {
89669       {
89670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89671       };
89672     } catch (std::exception& e) {
89673       {
89674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89675       };
89676     } catch (Dali::DaliException e) {
89677       {
89678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89679       };
89680     } catch (...) {
89681       {
89682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89683       };
89684     }
89685   }
89686
89687   jresult = (void *)result;
89688   return jresult;
89689 }
89690
89691
89692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89693   void * jresult ;
89694   std::vector< Dali::Actor > *arg1 = 0 ;
89695   std::vector< Dali::Actor > *result = 0 ;
89696
89697   arg1 = (std::vector< Dali::Actor > *)jarg1;
89698   if (!arg1) {
89699     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89700     return 0;
89701   }
89702   {
89703     try {
89704       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89705     } catch (std::out_of_range& e) {
89706       {
89707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89708       };
89709     } catch (std::exception& e) {
89710       {
89711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89712       };
89713     } catch (Dali::DaliException e) {
89714       {
89715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89716       };
89717     } catch (...) {
89718       {
89719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89720       };
89721     }
89722   }
89723
89724   jresult = (void *)result;
89725   return jresult;
89726 }
89727
89728
89729 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89730   void * jresult ;
89731   int arg1 ;
89732   std::vector< Dali::Actor > *result = 0 ;
89733
89734   arg1 = (int)jarg1;
89735   {
89736     try {
89737       try {
89738         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89739       }
89740       catch(std::out_of_range &_e) {
89741         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89742         return 0;
89743       }
89744
89745     } catch (std::out_of_range& e) {
89746       {
89747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89748       };
89749     } catch (std::exception& e) {
89750       {
89751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89752       };
89753     } catch (Dali::DaliException e) {
89754       {
89755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89756       };
89757     } catch (...) {
89758       {
89759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89760       };
89761     }
89762   }
89763
89764   jresult = (void *)result;
89765   return jresult;
89766 }
89767
89768
89769 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89770   void * jresult ;
89771   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89772   int arg2 ;
89773   Dali::Actor result;
89774
89775   arg1 = (std::vector< Dali::Actor > *)jarg1;
89776   arg2 = (int)jarg2;
89777   {
89778     try {
89779       try {
89780         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89781       }
89782       catch(std::out_of_range &_e) {
89783         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89784         return 0;
89785       }
89786
89787     } catch (std::out_of_range& e) {
89788       {
89789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89790       };
89791     } catch (std::exception& e) {
89792       {
89793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89794       };
89795     } catch (Dali::DaliException e) {
89796       {
89797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89798       };
89799     } catch (...) {
89800       {
89801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89802       };
89803     }
89804   }
89805
89806   jresult = new Dali::Actor((const Dali::Actor &)result);
89807   return jresult;
89808 }
89809
89810
89811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89812   void * jresult ;
89813   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89814   int arg2 ;
89815   Dali::Actor *result = 0 ;
89816
89817   arg1 = (std::vector< Dali::Actor > *)jarg1;
89818   arg2 = (int)jarg2;
89819   {
89820     try {
89821       try {
89822         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89823       }
89824       catch(std::out_of_range &_e) {
89825         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89826         return 0;
89827       }
89828
89829     } catch (std::out_of_range& e) {
89830       {
89831         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89832       };
89833     } catch (std::exception& e) {
89834       {
89835         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89836       };
89837     } catch (Dali::DaliException e) {
89838       {
89839         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89840       };
89841     } catch (...) {
89842       {
89843         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89844       };
89845     }
89846   }
89847
89848   jresult = (void *)result;
89849   return jresult;
89850 }
89851
89852
89853 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89854   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89855   int arg2 ;
89856   Dali::Actor *arg3 = 0 ;
89857
89858   arg1 = (std::vector< Dali::Actor > *)jarg1;
89859   arg2 = (int)jarg2;
89860   arg3 = (Dali::Actor *)jarg3;
89861   if (!arg3) {
89862     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89863     return ;
89864   }
89865   {
89866     try {
89867       try {
89868         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89869       }
89870       catch(std::out_of_range &_e) {
89871         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89872         return ;
89873       }
89874
89875     } catch (std::out_of_range& e) {
89876       {
89877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89878       };
89879     } catch (std::exception& e) {
89880       {
89881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89882       };
89883     } catch (Dali::DaliException e) {
89884       {
89885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89886       };
89887     } catch (...) {
89888       {
89889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89890       };
89891     }
89892   }
89893
89894 }
89895
89896
89897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89898   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89899   std::vector< Dali::Actor > *arg2 = 0 ;
89900
89901   arg1 = (std::vector< Dali::Actor > *)jarg1;
89902   arg2 = (std::vector< Dali::Actor > *)jarg2;
89903   if (!arg2) {
89904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89905     return ;
89906   }
89907   {
89908     try {
89909       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89910     } catch (std::out_of_range& e) {
89911       {
89912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89913       };
89914     } catch (std::exception& e) {
89915       {
89916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89917       };
89918     } catch (Dali::DaliException e) {
89919       {
89920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89921       };
89922     } catch (...) {
89923       {
89924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89925       };
89926     }
89927   }
89928
89929 }
89930
89931
89932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89933   void * jresult ;
89934   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89935   int arg2 ;
89936   int arg3 ;
89937   std::vector< Dali::Actor > *result = 0 ;
89938
89939   arg1 = (std::vector< Dali::Actor > *)jarg1;
89940   arg2 = (int)jarg2;
89941   arg3 = (int)jarg3;
89942   {
89943     try {
89944       try {
89945         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89946       }
89947       catch(std::out_of_range &_e) {
89948         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89949         return 0;
89950       }
89951       catch(std::invalid_argument &_e) {
89952         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89953         return 0;
89954       }
89955
89956     } catch (std::out_of_range& e) {
89957       {
89958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89959       };
89960     } catch (std::exception& e) {
89961       {
89962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89963       };
89964     } catch (Dali::DaliException e) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89967       };
89968     } catch (...) {
89969       {
89970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89971       };
89972     }
89973   }
89974
89975   jresult = (void *)result;
89976   return jresult;
89977 }
89978
89979
89980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89981   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89982   int arg2 ;
89983   Dali::Actor *arg3 = 0 ;
89984
89985   arg1 = (std::vector< Dali::Actor > *)jarg1;
89986   arg2 = (int)jarg2;
89987   arg3 = (Dali::Actor *)jarg3;
89988   if (!arg3) {
89989     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89990     return ;
89991   }
89992   {
89993     try {
89994       try {
89995         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89996       }
89997       catch(std::out_of_range &_e) {
89998         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89999         return ;
90000       }
90001
90002     } catch (std::out_of_range& e) {
90003       {
90004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90005       };
90006     } catch (std::exception& e) {
90007       {
90008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90009       };
90010     } catch (Dali::DaliException e) {
90011       {
90012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90013       };
90014     } catch (...) {
90015       {
90016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90017       };
90018     }
90019   }
90020
90021 }
90022
90023
90024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
90025   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90026   int arg2 ;
90027   std::vector< Dali::Actor > *arg3 = 0 ;
90028
90029   arg1 = (std::vector< Dali::Actor > *)jarg1;
90030   arg2 = (int)jarg2;
90031   arg3 = (std::vector< Dali::Actor > *)jarg3;
90032   if (!arg3) {
90033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90034     return ;
90035   }
90036   {
90037     try {
90038       try {
90039         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90040       }
90041       catch(std::out_of_range &_e) {
90042         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90043         return ;
90044       }
90045
90046     } catch (std::out_of_range& e) {
90047       {
90048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90049       };
90050     } catch (std::exception& e) {
90051       {
90052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90053       };
90054     } catch (Dali::DaliException e) {
90055       {
90056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90057       };
90058     } catch (...) {
90059       {
90060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90061       };
90062     }
90063   }
90064
90065 }
90066
90067
90068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
90069   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90070   int arg2 ;
90071
90072   arg1 = (std::vector< Dali::Actor > *)jarg1;
90073   arg2 = (int)jarg2;
90074   {
90075     try {
90076       try {
90077         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
90078       }
90079       catch(std::out_of_range &_e) {
90080         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90081         return ;
90082       }
90083
90084     } catch (std::out_of_range& e) {
90085       {
90086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90087       };
90088     } catch (std::exception& e) {
90089       {
90090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90091       };
90092     } catch (Dali::DaliException e) {
90093       {
90094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90095       };
90096     } catch (...) {
90097       {
90098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90099       };
90100     }
90101   }
90102
90103 }
90104
90105
90106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
90107   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90108   int arg2 ;
90109   int arg3 ;
90110
90111   arg1 = (std::vector< Dali::Actor > *)jarg1;
90112   arg2 = (int)jarg2;
90113   arg3 = (int)jarg3;
90114   {
90115     try {
90116       try {
90117         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
90118       }
90119       catch(std::out_of_range &_e) {
90120         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90121         return ;
90122       }
90123       catch(std::invalid_argument &_e) {
90124         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90125         return ;
90126       }
90127
90128     } catch (std::out_of_range& e) {
90129       {
90130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90131       };
90132     } catch (std::exception& e) {
90133       {
90134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90135       };
90136     } catch (Dali::DaliException e) {
90137       {
90138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90139       };
90140     } catch (...) {
90141       {
90142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90143       };
90144     }
90145   }
90146
90147 }
90148
90149
90150 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
90151   void * jresult ;
90152   Dali::Actor *arg1 = 0 ;
90153   int arg2 ;
90154   std::vector< Dali::Actor > *result = 0 ;
90155
90156   arg1 = (Dali::Actor *)jarg1;
90157   if (!arg1) {
90158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
90159     return 0;
90160   }
90161   arg2 = (int)jarg2;
90162   {
90163     try {
90164       try {
90165         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
90166       }
90167       catch(std::out_of_range &_e) {
90168         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90169         return 0;
90170       }
90171
90172     } catch (std::out_of_range& e) {
90173       {
90174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90175       };
90176     } catch (std::exception& e) {
90177       {
90178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90179       };
90180     } catch (Dali::DaliException e) {
90181       {
90182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90183       };
90184     } catch (...) {
90185       {
90186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90187       };
90188     }
90189   }
90190
90191   jresult = (void *)result;
90192   return jresult;
90193 }
90194
90195
90196 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
90197   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90198
90199   arg1 = (std::vector< Dali::Actor > *)jarg1;
90200   {
90201     try {
90202       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
90203     } catch (std::out_of_range& e) {
90204       {
90205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90206       };
90207     } catch (std::exception& e) {
90208       {
90209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90210       };
90211     } catch (Dali::DaliException e) {
90212       {
90213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90214       };
90215     } catch (...) {
90216       {
90217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90218       };
90219     }
90220   }
90221
90222 }
90223
90224
90225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
90226   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90227   int arg2 ;
90228   int arg3 ;
90229
90230   arg1 = (std::vector< Dali::Actor > *)jarg1;
90231   arg2 = (int)jarg2;
90232   arg3 = (int)jarg3;
90233   {
90234     try {
90235       try {
90236         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
90237       }
90238       catch(std::out_of_range &_e) {
90239         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90240         return ;
90241       }
90242       catch(std::invalid_argument &_e) {
90243         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
90244         return ;
90245       }
90246
90247     } catch (std::out_of_range& e) {
90248       {
90249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90250       };
90251     } catch (std::exception& e) {
90252       {
90253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90254       };
90255     } catch (Dali::DaliException e) {
90256       {
90257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90258       };
90259     } catch (...) {
90260       {
90261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90262       };
90263     }
90264   }
90265
90266 }
90267
90268
90269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
90270   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90271   int arg2 ;
90272   std::vector< Dali::Actor > *arg3 = 0 ;
90273
90274   arg1 = (std::vector< Dali::Actor > *)jarg1;
90275   arg2 = (int)jarg2;
90276   arg3 = (std::vector< Dali::Actor > *)jarg3;
90277   if (!arg3) {
90278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
90279     return ;
90280   }
90281   {
90282     try {
90283       try {
90284         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
90285       }
90286       catch(std::out_of_range &_e) {
90287         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
90288         return ;
90289       }
90290
90291     } catch (std::out_of_range& e) {
90292       {
90293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90294       };
90295     } catch (std::exception& e) {
90296       {
90297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90298       };
90299     } catch (Dali::DaliException e) {
90300       {
90301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90302       };
90303     } catch (...) {
90304       {
90305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90306       };
90307     }
90308   }
90309
90310 }
90311
90312
90313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
90314   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
90315
90316   arg1 = (std::vector< Dali::Actor > *)jarg1;
90317   {
90318     try {
90319       delete arg1;
90320     } catch (std::out_of_range& e) {
90321       {
90322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90323       };
90324     } catch (std::exception& e) {
90325       {
90326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90327       };
90328     } catch (Dali::DaliException e) {
90329       {
90330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90331       };
90332     } catch (...) {
90333       {
90334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90335       };
90336     }
90337   }
90338
90339 }
90340
90341
90342 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
90343   unsigned int jresult ;
90344   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90345   bool result;
90346
90347   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90348   {
90349     try {
90350       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90351     } catch (std::out_of_range& e) {
90352       {
90353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90354       };
90355     } catch (std::exception& e) {
90356       {
90357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90358       };
90359     } catch (Dali::DaliException e) {
90360       {
90361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90362       };
90363     } catch (...) {
90364       {
90365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90366       };
90367     }
90368   }
90369
90370   jresult = result;
90371   return jresult;
90372 }
90373
90374
90375 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
90376   unsigned long jresult ;
90377   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90378   std::size_t result;
90379
90380   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90381   {
90382     try {
90383       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
90384     } catch (std::out_of_range& e) {
90385       {
90386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90387       };
90388     } catch (std::exception& e) {
90389       {
90390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90391       };
90392     } catch (Dali::DaliException e) {
90393       {
90394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90395       };
90396     } catch (...) {
90397       {
90398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90399       };
90400     }
90401   }
90402
90403   jresult = (unsigned long)result;
90404   return jresult;
90405 }
90406
90407
90408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
90409   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90410   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90411
90412   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90413   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90414   {
90415     try {
90416       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
90417     } catch (std::out_of_range& e) {
90418       {
90419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90420       };
90421     } catch (std::exception& e) {
90422       {
90423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90424       };
90425     } catch (Dali::DaliException e) {
90426       {
90427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90428       };
90429     } catch (...) {
90430       {
90431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90432       };
90433     }
90434   }
90435
90436 }
90437
90438
90439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
90440   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90441   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
90442
90443   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90444   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
90445   {
90446     try {
90447       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
90448     } catch (std::out_of_range& e) {
90449       {
90450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90451       };
90452     } catch (std::exception& e) {
90453       {
90454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90455       };
90456     } catch (Dali::DaliException e) {
90457       {
90458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90459       };
90460     } catch (...) {
90461       {
90462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90463       };
90464     }
90465   }
90466
90467 }
90468
90469
90470 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
90471   unsigned int jresult ;
90472   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90473   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
90474   bool result;
90475
90476   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90477   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
90478   if (!arg2) {
90479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
90480     return 0;
90481   }
90482   {
90483     try {
90484       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
90485     } catch (std::out_of_range& e) {
90486       {
90487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90488       };
90489     } catch (std::exception& e) {
90490       {
90491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90492       };
90493     } catch (Dali::DaliException e) {
90494       {
90495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90496       };
90497     } catch (...) {
90498       {
90499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90500       };
90501     }
90502   }
90503
90504   jresult = result;
90505   return jresult;
90506 }
90507
90508
90509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90510   void * jresult ;
90511   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90512
90513   {
90514     try {
90515       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90516     } catch (std::out_of_range& e) {
90517       {
90518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90519       };
90520     } catch (std::exception& e) {
90521       {
90522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90523       };
90524     } catch (Dali::DaliException e) {
90525       {
90526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90527       };
90528     } catch (...) {
90529       {
90530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90531       };
90532     }
90533   }
90534
90535   jresult = (void *)result;
90536   return jresult;
90537 }
90538
90539
90540 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90541   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90542
90543   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90544   {
90545     try {
90546       delete arg1;
90547     } catch (std::out_of_range& e) {
90548       {
90549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90550       };
90551     } catch (std::exception& e) {
90552       {
90553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90554       };
90555     } catch (Dali::DaliException e) {
90556       {
90557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90558       };
90559     } catch (...) {
90560       {
90561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90562       };
90563     }
90564   }
90565
90566 }
90567
90568
90569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90570   unsigned int jresult ;
90571   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90572   bool result;
90573
90574   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90575   {
90576     try {
90577       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);
90578     } catch (std::out_of_range& e) {
90579       {
90580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90581       };
90582     } catch (std::exception& e) {
90583       {
90584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90585       };
90586     } catch (Dali::DaliException e) {
90587       {
90588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90589       };
90590     } catch (...) {
90591       {
90592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90593       };
90594     }
90595   }
90596
90597   jresult = result;
90598   return jresult;
90599 }
90600
90601
90602 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90603   unsigned long jresult ;
90604   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90605   std::size_t result;
90606
90607   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90608   {
90609     try {
90610       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);
90611     } catch (std::out_of_range& e) {
90612       {
90613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90614       };
90615     } catch (std::exception& e) {
90616       {
90617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90618       };
90619     } catch (Dali::DaliException e) {
90620       {
90621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90622       };
90623     } catch (...) {
90624       {
90625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90626       };
90627     }
90628   }
90629
90630   jresult = (unsigned long)result;
90631   return jresult;
90632 }
90633
90634
90635 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90636   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90637   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90638
90639   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90640   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90641   {
90642     try {
90643       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90644     } catch (std::out_of_range& e) {
90645       {
90646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90647       };
90648     } catch (std::exception& e) {
90649       {
90650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90651       };
90652     } catch (Dali::DaliException e) {
90653       {
90654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90655       };
90656     } catch (...) {
90657       {
90658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90659       };
90660     }
90661   }
90662
90663 }
90664
90665
90666 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90667   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90668   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90669
90670   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90671   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90672   {
90673     try {
90674       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90675     } catch (std::out_of_range& e) {
90676       {
90677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90678       };
90679     } catch (std::exception& e) {
90680       {
90681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90682       };
90683     } catch (Dali::DaliException e) {
90684       {
90685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90686       };
90687     } catch (...) {
90688       {
90689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90690       };
90691     }
90692   }
90693
90694 }
90695
90696
90697 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90698   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90699   Dali::Actor arg2 ;
90700   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90701   Dali::Actor *argp2 ;
90702
90703   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90704   argp2 = (Dali::Actor *)jarg2;
90705   if (!argp2) {
90706     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90707     return ;
90708   }
90709   arg2 = *argp2;
90710   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90711   {
90712     try {
90713       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90714     } catch (std::out_of_range& e) {
90715       {
90716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90717       };
90718     } catch (std::exception& e) {
90719       {
90720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90721       };
90722     } catch (Dali::DaliException e) {
90723       {
90724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90725       };
90726     } catch (...) {
90727       {
90728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90729       };
90730     }
90731   }
90732
90733 }
90734
90735
90736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90737   void * jresult ;
90738   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90739
90740   {
90741     try {
90742       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90743     } catch (std::out_of_range& e) {
90744       {
90745         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90746       };
90747     } catch (std::exception& e) {
90748       {
90749         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90750       };
90751     } catch (Dali::DaliException e) {
90752       {
90753         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90754       };
90755     } catch (...) {
90756       {
90757         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90758       };
90759     }
90760   }
90761
90762   jresult = (void *)result;
90763   return jresult;
90764 }
90765
90766
90767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90768   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90769
90770   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90771   {
90772     try {
90773       delete arg1;
90774     } catch (std::out_of_range& e) {
90775       {
90776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90777       };
90778     } catch (std::exception& e) {
90779       {
90780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90781       };
90782     } catch (Dali::DaliException e) {
90783       {
90784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90785       };
90786     } catch (...) {
90787       {
90788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90789       };
90790     }
90791   }
90792
90793 }
90794
90795
90796 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90797   unsigned int jresult ;
90798   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90799   bool result;
90800
90801   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90802   {
90803     try {
90804       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90805     } catch (std::out_of_range& e) {
90806       {
90807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90808       };
90809     } catch (std::exception& e) {
90810       {
90811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90812       };
90813     } catch (Dali::DaliException e) {
90814       {
90815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90816       };
90817     } catch (...) {
90818       {
90819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90820       };
90821     }
90822   }
90823
90824   jresult = result;
90825   return jresult;
90826 }
90827
90828
90829 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90830   unsigned long jresult ;
90831   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90832   std::size_t result;
90833
90834   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90835   {
90836     try {
90837       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90838     } catch (std::out_of_range& e) {
90839       {
90840         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90841       };
90842     } catch (std::exception& e) {
90843       {
90844         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90845       };
90846     } catch (Dali::DaliException e) {
90847       {
90848         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90849       };
90850     } catch (...) {
90851       {
90852         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90853       };
90854     }
90855   }
90856
90857   jresult = (unsigned long)result;
90858   return jresult;
90859 }
90860
90861
90862 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90863   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90864   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90865
90866   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90867   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90868   {
90869     try {
90870       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90871     } catch (std::out_of_range& e) {
90872       {
90873         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90874       };
90875     } catch (std::exception& e) {
90876       {
90877         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90878       };
90879     } catch (Dali::DaliException e) {
90880       {
90881         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90882       };
90883     } catch (...) {
90884       {
90885         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90886       };
90887     }
90888   }
90889
90890 }
90891
90892
90893 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90894   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90895   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90896
90897   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90898   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90899   {
90900     try {
90901       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90902     } catch (std::out_of_range& e) {
90903       {
90904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90905       };
90906     } catch (std::exception& e) {
90907       {
90908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90909       };
90910     } catch (Dali::DaliException e) {
90911       {
90912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90913       };
90914     } catch (...) {
90915       {
90916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90917       };
90918     }
90919   }
90920
90921 }
90922
90923
90924 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90925   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90926   Dali::Actor arg2 ;
90927   Dali::Actor arg3 ;
90928   Dali::Actor *argp2 ;
90929   Dali::Actor *argp3 ;
90930
90931   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90932   argp2 = (Dali::Actor *)jarg2;
90933   if (!argp2) {
90934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90935     return ;
90936   }
90937   arg2 = *argp2;
90938   argp3 = (Dali::Actor *)jarg3;
90939   if (!argp3) {
90940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90941     return ;
90942   }
90943   arg3 = *argp3;
90944   {
90945     try {
90946       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90947     } catch (std::out_of_range& e) {
90948       {
90949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90950       };
90951     } catch (std::exception& e) {
90952       {
90953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90954       };
90955     } catch (Dali::DaliException e) {
90956       {
90957         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90958       };
90959     } catch (...) {
90960       {
90961         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90962       };
90963     }
90964   }
90965
90966 }
90967
90968
90969 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90970   void * jresult ;
90971   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90972
90973   {
90974     try {
90975       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90976     } catch (std::out_of_range& e) {
90977       {
90978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90979       };
90980     } catch (std::exception& e) {
90981       {
90982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90983       };
90984     } catch (Dali::DaliException e) {
90985       {
90986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90987       };
90988     } catch (...) {
90989       {
90990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90991       };
90992     }
90993   }
90994
90995   jresult = (void *)result;
90996   return jresult;
90997 }
90998
90999
91000 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
91001   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
91002
91003   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
91004   {
91005     try {
91006       delete arg1;
91007     } catch (std::out_of_range& e) {
91008       {
91009         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91010       };
91011     } catch (std::exception& e) {
91012       {
91013         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91014       };
91015     } catch (Dali::DaliException e) {
91016       {
91017         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91018       };
91019     } catch (...) {
91020       {
91021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91022       };
91023     }
91024   }
91025
91026 }
91027
91028
91029 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
91030   unsigned int jresult ;
91031   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91032   bool result;
91033
91034   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91035   {
91036     try {
91037       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91038     } catch (std::out_of_range& e) {
91039       {
91040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91041       };
91042     } catch (std::exception& e) {
91043       {
91044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91045       };
91046     } catch (Dali::DaliException e) {
91047       {
91048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91049       };
91050     } catch (...) {
91051       {
91052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91053       };
91054     }
91055   }
91056
91057   jresult = result;
91058   return jresult;
91059 }
91060
91061
91062 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
91063   unsigned long jresult ;
91064   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91065   std::size_t result;
91066
91067   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91068   {
91069     try {
91070       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
91071     } catch (std::out_of_range& e) {
91072       {
91073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91074       };
91075     } catch (std::exception& e) {
91076       {
91077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91078       };
91079     } catch (Dali::DaliException e) {
91080       {
91081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91082       };
91083     } catch (...) {
91084       {
91085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91086       };
91087     }
91088   }
91089
91090   jresult = (unsigned long)result;
91091   return jresult;
91092 }
91093
91094
91095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
91096   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91097   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91098
91099   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91100   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91101   {
91102     try {
91103       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
91104     } catch (std::out_of_range& e) {
91105       {
91106         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91107       };
91108     } catch (std::exception& e) {
91109       {
91110         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91111       };
91112     } catch (Dali::DaliException e) {
91113       {
91114         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91115       };
91116     } catch (...) {
91117       {
91118         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91119       };
91120     }
91121   }
91122
91123 }
91124
91125
91126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91127   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91128   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
91129
91130   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91131   arg2 = (void (*)(Dali::Actor,bool))jarg2;
91132   {
91133     try {
91134       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91135     } catch (std::out_of_range& e) {
91136       {
91137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91138       };
91139     } catch (std::exception& e) {
91140       {
91141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91142       };
91143     } catch (Dali::DaliException e) {
91144       {
91145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91146       };
91147     } catch (...) {
91148       {
91149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91150       };
91151     }
91152   }
91153
91154 }
91155
91156
91157 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
91158   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91159   Dali::Actor arg2 ;
91160   bool arg3 ;
91161   Dali::Actor *argp2 ;
91162
91163   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91164   argp2 = (Dali::Actor *)jarg2;
91165   if (!argp2) {
91166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
91167     return ;
91168   }
91169   arg2 = *argp2;
91170   arg3 = jarg3 ? true : false;
91171   {
91172     try {
91173       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
91174     } catch (std::out_of_range& e) {
91175       {
91176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91177       };
91178     } catch (std::exception& e) {
91179       {
91180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91181       };
91182     } catch (Dali::DaliException e) {
91183       {
91184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91185       };
91186     } catch (...) {
91187       {
91188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91189       };
91190     }
91191   }
91192
91193 }
91194
91195
91196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
91197   void * jresult ;
91198   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
91199
91200   {
91201     try {
91202       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
91203     } catch (std::out_of_range& e) {
91204       {
91205         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91206       };
91207     } catch (std::exception& e) {
91208       {
91209         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91210       };
91211     } catch (Dali::DaliException e) {
91212       {
91213         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91214       };
91215     } catch (...) {
91216       {
91217         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91218       };
91219     }
91220   }
91221
91222   jresult = (void *)result;
91223   return jresult;
91224 }
91225
91226
91227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
91228   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
91229
91230   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
91231   {
91232     try {
91233       delete arg1;
91234     } catch (std::out_of_range& e) {
91235       {
91236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91237       };
91238     } catch (std::exception& e) {
91239       {
91240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91241       };
91242     } catch (Dali::DaliException e) {
91243       {
91244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91245       };
91246     } catch (...) {
91247       {
91248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91249       };
91250     }
91251   }
91252
91253 }
91254
91255
91256 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
91257   unsigned int jresult ;
91258   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91259   bool result;
91260
91261   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91262   {
91263     try {
91264       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);
91265     } catch (std::out_of_range& e) {
91266       {
91267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91268       };
91269     } catch (std::exception& e) {
91270       {
91271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91272       };
91273     } catch (Dali::DaliException e) {
91274       {
91275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91276       };
91277     } catch (...) {
91278       {
91279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91280       };
91281     }
91282   }
91283
91284   jresult = result;
91285   return jresult;
91286 }
91287
91288
91289 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
91290   unsigned long jresult ;
91291   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91292   std::size_t result;
91293
91294   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91295   {
91296     try {
91297       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);
91298     } catch (std::out_of_range& e) {
91299       {
91300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91301       };
91302     } catch (std::exception& e) {
91303       {
91304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91305       };
91306     } catch (Dali::DaliException e) {
91307       {
91308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91309       };
91310     } catch (...) {
91311       {
91312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91313       };
91314     }
91315   }
91316
91317   jresult = (unsigned long)result;
91318   return jresult;
91319 }
91320
91321
91322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
91323   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91324   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91325
91326   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91327   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91328   {
91329     try {
91330       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
91331     } catch (std::out_of_range& e) {
91332       {
91333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91334       };
91335     } catch (std::exception& e) {
91336       {
91337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91338       };
91339     } catch (Dali::DaliException e) {
91340       {
91341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91342       };
91343     } catch (...) {
91344       {
91345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91346       };
91347     }
91348   }
91349
91350 }
91351
91352
91353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91354   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91355   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
91356
91357   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91358   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
91359   {
91360     try {
91361       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
91362     } catch (std::out_of_range& e) {
91363       {
91364         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91365       };
91366     } catch (std::exception& e) {
91367       {
91368         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91369       };
91370     } catch (Dali::DaliException e) {
91371       {
91372         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91373       };
91374     } catch (...) {
91375       {
91376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91377       };
91378     }
91379   }
91380
91381 }
91382
91383
91384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
91385   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91386   Dali::Toolkit::StyleManager arg2 ;
91387   Dali::StyleChange::Type arg3 ;
91388   Dali::Toolkit::StyleManager *argp2 ;
91389
91390   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91391   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
91392   if (!argp2) {
91393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
91394     return ;
91395   }
91396   arg2 = *argp2;
91397   arg3 = (Dali::StyleChange::Type)jarg3;
91398   {
91399     try {
91400       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
91401     } catch (std::out_of_range& e) {
91402       {
91403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91404       };
91405     } catch (std::exception& e) {
91406       {
91407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91408       };
91409     } catch (Dali::DaliException e) {
91410       {
91411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91412       };
91413     } catch (...) {
91414       {
91415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91416       };
91417     }
91418   }
91419
91420 }
91421
91422
91423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
91424   void * jresult ;
91425   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
91426
91427   {
91428     try {
91429       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
91430     } catch (std::out_of_range& e) {
91431       {
91432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91433       };
91434     } catch (std::exception& e) {
91435       {
91436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91437       };
91438     } catch (Dali::DaliException e) {
91439       {
91440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91441       };
91442     } catch (...) {
91443       {
91444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91445       };
91446     }
91447   }
91448
91449   jresult = (void *)result;
91450   return jresult;
91451 }
91452
91453
91454 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
91455   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
91456
91457   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
91458   {
91459     try {
91460       delete arg1;
91461     } catch (std::out_of_range& e) {
91462       {
91463         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91464       };
91465     } catch (std::exception& e) {
91466       {
91467         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91468       };
91469     } catch (Dali::DaliException e) {
91470       {
91471         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91472       };
91473     } catch (...) {
91474       {
91475         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91476       };
91477     }
91478   }
91479
91480 }
91481
91482
91483 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
91484   unsigned int jresult ;
91485   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91486   bool result;
91487
91488   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91489   {
91490     try {
91491       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91492     } catch (std::out_of_range& e) {
91493       {
91494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91495       };
91496     } catch (std::exception& e) {
91497       {
91498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91499       };
91500     } catch (Dali::DaliException e) {
91501       {
91502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91503       };
91504     } catch (...) {
91505       {
91506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91507       };
91508     }
91509   }
91510
91511   jresult = result;
91512   return jresult;
91513 }
91514
91515
91516 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91517   unsigned long jresult ;
91518   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91519   std::size_t result;
91520
91521   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91522   {
91523     try {
91524       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91525     } catch (std::out_of_range& e) {
91526       {
91527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91528       };
91529     } catch (std::exception& e) {
91530       {
91531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91532       };
91533     } catch (Dali::DaliException e) {
91534       {
91535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91536       };
91537     } catch (...) {
91538       {
91539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91540       };
91541     }
91542   }
91543
91544   jresult = (unsigned long)result;
91545   return jresult;
91546 }
91547
91548
91549 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91550   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91551   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91552
91553   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91554   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91555   {
91556     try {
91557       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91558     } catch (std::out_of_range& e) {
91559       {
91560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91561       };
91562     } catch (std::exception& e) {
91563       {
91564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91565       };
91566     } catch (Dali::DaliException e) {
91567       {
91568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91569       };
91570     } catch (...) {
91571       {
91572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91573       };
91574     }
91575   }
91576
91577 }
91578
91579
91580 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91581   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91582   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91583
91584   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91585   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91586   {
91587     try {
91588       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91589     } catch (std::out_of_range& e) {
91590       {
91591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91592       };
91593     } catch (std::exception& e) {
91594       {
91595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91596       };
91597     } catch (Dali::DaliException e) {
91598       {
91599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91600       };
91601     } catch (...) {
91602       {
91603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91604       };
91605     }
91606   }
91607
91608 }
91609
91610
91611 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91612   unsigned int jresult ;
91613   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91614   Dali::Toolkit::Button arg2 ;
91615   Dali::Toolkit::Button *argp2 ;
91616   bool result;
91617
91618   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91619   argp2 = (Dali::Toolkit::Button *)jarg2;
91620   if (!argp2) {
91621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91622     return 0;
91623   }
91624   arg2 = *argp2;
91625   {
91626     try {
91627       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91628     } catch (std::out_of_range& e) {
91629       {
91630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91631       };
91632     } catch (std::exception& e) {
91633       {
91634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91635       };
91636     } catch (Dali::DaliException e) {
91637       {
91638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91639       };
91640     } catch (...) {
91641       {
91642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91643       };
91644     }
91645   }
91646
91647   jresult = result;
91648   return jresult;
91649 }
91650
91651
91652 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91653   void * jresult ;
91654   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91655
91656   {
91657     try {
91658       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91659     } catch (std::out_of_range& e) {
91660       {
91661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91662       };
91663     } catch (std::exception& e) {
91664       {
91665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91666       };
91667     } catch (Dali::DaliException e) {
91668       {
91669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91670       };
91671     } catch (...) {
91672       {
91673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91674       };
91675     }
91676   }
91677
91678   jresult = (void *)result;
91679   return jresult;
91680 }
91681
91682
91683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91684   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91685
91686   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91687   {
91688     try {
91689       delete arg1;
91690     } catch (std::out_of_range& e) {
91691       {
91692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91693       };
91694     } catch (std::exception& e) {
91695       {
91696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91697       };
91698     } catch (Dali::DaliException e) {
91699       {
91700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91701       };
91702     } catch (...) {
91703       {
91704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91705       };
91706     }
91707   }
91708
91709 }
91710
91711
91712 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91713   unsigned int jresult ;
91714   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91715   bool result;
91716
91717   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91718   {
91719     try {
91720       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91721     } catch (std::out_of_range& e) {
91722       {
91723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91724       };
91725     } catch (std::exception& e) {
91726       {
91727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91728       };
91729     } catch (Dali::DaliException e) {
91730       {
91731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91732       };
91733     } catch (...) {
91734       {
91735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91736       };
91737     }
91738   }
91739
91740   jresult = result;
91741   return jresult;
91742 }
91743
91744
91745 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91746   unsigned long jresult ;
91747   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91748   std::size_t result;
91749
91750   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91751   {
91752     try {
91753       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91754     } catch (std::out_of_range& e) {
91755       {
91756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91757       };
91758     } catch (std::exception& e) {
91759       {
91760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91761       };
91762     } catch (Dali::DaliException e) {
91763       {
91764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91765       };
91766     } catch (...) {
91767       {
91768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91769       };
91770     }
91771   }
91772
91773   jresult = (unsigned long)result;
91774   return jresult;
91775 }
91776
91777
91778 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91779   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91780   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91781
91782   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91783   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91784   {
91785     try {
91786       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91787     } catch (std::out_of_range& e) {
91788       {
91789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91790       };
91791     } catch (std::exception& e) {
91792       {
91793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91794       };
91795     } catch (Dali::DaliException e) {
91796       {
91797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91798       };
91799     } catch (...) {
91800       {
91801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91802       };
91803     }
91804   }
91805
91806 }
91807
91808
91809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91810   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91811   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91812
91813   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91814   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91815   {
91816     try {
91817       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91818     } catch (std::out_of_range& e) {
91819       {
91820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91821       };
91822     } catch (std::exception& e) {
91823       {
91824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91825       };
91826     } catch (Dali::DaliException e) {
91827       {
91828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91829       };
91830     } catch (...) {
91831       {
91832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91833       };
91834     }
91835   }
91836
91837 }
91838
91839
91840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91841   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91842   Dali::Toolkit::GaussianBlurView arg2 ;
91843   Dali::Toolkit::GaussianBlurView *argp2 ;
91844
91845   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91846   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91847   if (!argp2) {
91848     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91849     return ;
91850   }
91851   arg2 = *argp2;
91852   {
91853     try {
91854       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91855     } catch (std::out_of_range& e) {
91856       {
91857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91858       };
91859     } catch (std::exception& e) {
91860       {
91861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91862       };
91863     } catch (Dali::DaliException e) {
91864       {
91865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91866       };
91867     } catch (...) {
91868       {
91869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91870       };
91871     }
91872   }
91873
91874 }
91875
91876
91877 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91878   void * jresult ;
91879   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91880
91881   {
91882     try {
91883       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91884     } catch (std::out_of_range& e) {
91885       {
91886         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91887       };
91888     } catch (std::exception& e) {
91889       {
91890         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91891       };
91892     } catch (Dali::DaliException e) {
91893       {
91894         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91895       };
91896     } catch (...) {
91897       {
91898         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91899       };
91900     }
91901   }
91902
91903   jresult = (void *)result;
91904   return jresult;
91905 }
91906
91907
91908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91909   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91910
91911   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91912   {
91913     try {
91914       delete arg1;
91915     } catch (std::out_of_range& e) {
91916       {
91917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91918       };
91919     } catch (std::exception& e) {
91920       {
91921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91922       };
91923     } catch (Dali::DaliException e) {
91924       {
91925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91926       };
91927     } catch (...) {
91928       {
91929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91930       };
91931     }
91932   }
91933
91934 }
91935
91936
91937 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91938   unsigned int jresult ;
91939   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91940   bool result;
91941
91942   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91943   {
91944     try {
91945       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);
91946     } catch (std::out_of_range& e) {
91947       {
91948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91949       };
91950     } catch (std::exception& e) {
91951       {
91952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91953       };
91954     } catch (Dali::DaliException e) {
91955       {
91956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91957       };
91958     } catch (...) {
91959       {
91960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91961       };
91962     }
91963   }
91964
91965   jresult = result;
91966   return jresult;
91967 }
91968
91969
91970 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91971   unsigned long jresult ;
91972   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91973   std::size_t result;
91974
91975   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91976   {
91977     try {
91978       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);
91979     } catch (std::out_of_range& e) {
91980       {
91981         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91982       };
91983     } catch (std::exception& e) {
91984       {
91985         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91986       };
91987     } catch (Dali::DaliException e) {
91988       {
91989         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91990       };
91991     } catch (...) {
91992       {
91993         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91994       };
91995     }
91996   }
91997
91998   jresult = (unsigned long)result;
91999   return jresult;
92000 }
92001
92002
92003 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
92004   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92005   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
92006
92007   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92008   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
92009   {
92010     try {
92011       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
92012     } catch (std::out_of_range& e) {
92013       {
92014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92015       };
92016     } catch (std::exception& e) {
92017       {
92018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92019       };
92020     } catch (Dali::DaliException e) {
92021       {
92022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92023       };
92024     } catch (...) {
92025       {
92026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92027       };
92028     }
92029   }
92030
92031 }
92032
92033
92034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
92035   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92036   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
92037
92038   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92039   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
92040   {
92041     try {
92042       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
92043     } catch (std::out_of_range& e) {
92044       {
92045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92046       };
92047     } catch (std::exception& e) {
92048       {
92049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92050       };
92051     } catch (Dali::DaliException e) {
92052       {
92053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92054       };
92055     } catch (...) {
92056       {
92057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92058       };
92059     }
92060   }
92061
92062 }
92063
92064
92065 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
92066   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92067   Dali::Toolkit::PageTurnView arg2 ;
92068   unsigned int arg3 ;
92069   bool arg4 ;
92070   Dali::Toolkit::PageTurnView *argp2 ;
92071
92072   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92073   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92074   if (!argp2) {
92075     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92076     return ;
92077   }
92078   arg2 = *argp2;
92079   arg3 = (unsigned int)jarg3;
92080   arg4 = jarg4 ? true : false;
92081   {
92082     try {
92083       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92084     } catch (std::out_of_range& e) {
92085       {
92086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92087       };
92088     } catch (std::exception& e) {
92089       {
92090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92091       };
92092     } catch (Dali::DaliException e) {
92093       {
92094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92095       };
92096     } catch (...) {
92097       {
92098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92099       };
92100     }
92101   }
92102
92103 }
92104
92105
92106 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
92107   void * jresult ;
92108   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
92109
92110   {
92111     try {
92112       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
92113     } catch (std::out_of_range& e) {
92114       {
92115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92116       };
92117     } catch (std::exception& e) {
92118       {
92119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92120       };
92121     } catch (Dali::DaliException e) {
92122       {
92123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92124       };
92125     } catch (...) {
92126       {
92127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92128       };
92129     }
92130   }
92131
92132   jresult = (void *)result;
92133   return jresult;
92134 }
92135
92136
92137 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
92138   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
92139
92140   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
92141   {
92142     try {
92143       delete arg1;
92144     } catch (std::out_of_range& e) {
92145       {
92146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92147       };
92148     } catch (std::exception& e) {
92149       {
92150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92151       };
92152     } catch (Dali::DaliException e) {
92153       {
92154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92155       };
92156     } catch (...) {
92157       {
92158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92159       };
92160     }
92161   }
92162
92163 }
92164
92165
92166 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
92167   unsigned int jresult ;
92168   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92169   bool result;
92170
92171   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92172   {
92173     try {
92174       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92175     } catch (std::out_of_range& e) {
92176       {
92177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92178       };
92179     } catch (std::exception& e) {
92180       {
92181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92182       };
92183     } catch (Dali::DaliException e) {
92184       {
92185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92186       };
92187     } catch (...) {
92188       {
92189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92190       };
92191     }
92192   }
92193
92194   jresult = result;
92195   return jresult;
92196 }
92197
92198
92199 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
92200   unsigned long jresult ;
92201   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92202   std::size_t result;
92203
92204   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92205   {
92206     try {
92207       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
92208     } catch (std::out_of_range& e) {
92209       {
92210         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92211       };
92212     } catch (std::exception& e) {
92213       {
92214         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92215       };
92216     } catch (Dali::DaliException e) {
92217       {
92218         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92219       };
92220     } catch (...) {
92221       {
92222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92223       };
92224     }
92225   }
92226
92227   jresult = (unsigned long)result;
92228   return jresult;
92229 }
92230
92231
92232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
92233   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92234   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92235
92236   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92237   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92238   {
92239     try {
92240       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
92241     } catch (std::out_of_range& e) {
92242       {
92243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92244       };
92245     } catch (std::exception& e) {
92246       {
92247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92248       };
92249     } catch (Dali::DaliException e) {
92250       {
92251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92252       };
92253     } catch (...) {
92254       {
92255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92256       };
92257     }
92258   }
92259
92260 }
92261
92262
92263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
92264   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92265   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
92266
92267   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92268   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
92269   {
92270     try {
92271       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
92272     } catch (std::out_of_range& e) {
92273       {
92274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92275       };
92276     } catch (std::exception& e) {
92277       {
92278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92279       };
92280     } catch (Dali::DaliException e) {
92281       {
92282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92283       };
92284     } catch (...) {
92285       {
92286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92287       };
92288     }
92289   }
92290
92291 }
92292
92293
92294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
92295   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92296   Dali::Toolkit::PageTurnView arg2 ;
92297   Dali::Toolkit::PageTurnView *argp2 ;
92298
92299   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92300   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
92301   if (!argp2) {
92302     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
92303     return ;
92304   }
92305   arg2 = *argp2;
92306   {
92307     try {
92308       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
92309     } catch (std::out_of_range& e) {
92310       {
92311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92312       };
92313     } catch (std::exception& e) {
92314       {
92315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92316       };
92317     } catch (Dali::DaliException e) {
92318       {
92319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92320       };
92321     } catch (...) {
92322       {
92323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92324       };
92325     }
92326   }
92327
92328 }
92329
92330
92331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
92332   void * jresult ;
92333   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
92334
92335   {
92336     try {
92337       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
92338     } catch (std::out_of_range& e) {
92339       {
92340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92341       };
92342     } catch (std::exception& e) {
92343       {
92344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92345       };
92346     } catch (Dali::DaliException e) {
92347       {
92348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92349       };
92350     } catch (...) {
92351       {
92352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92353       };
92354     }
92355   }
92356
92357   jresult = (void *)result;
92358   return jresult;
92359 }
92360
92361
92362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
92363   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
92364
92365   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
92366   {
92367     try {
92368       delete arg1;
92369     } catch (std::out_of_range& e) {
92370       {
92371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92372       };
92373     } catch (std::exception& e) {
92374       {
92375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92376       };
92377     } catch (Dali::DaliException e) {
92378       {
92379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92380       };
92381     } catch (...) {
92382       {
92383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92384       };
92385     }
92386   }
92387
92388 }
92389
92390
92391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
92392   unsigned int jresult ;
92393   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92394   bool result;
92395
92396   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92397   {
92398     try {
92399       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);
92400     } catch (std::out_of_range& e) {
92401       {
92402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92403       };
92404     } catch (std::exception& e) {
92405       {
92406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92407       };
92408     } catch (Dali::DaliException e) {
92409       {
92410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92411       };
92412     } catch (...) {
92413       {
92414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92415       };
92416     }
92417   }
92418
92419   jresult = result;
92420   return jresult;
92421 }
92422
92423
92424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
92425   unsigned long jresult ;
92426   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92427   std::size_t result;
92428
92429   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92430   {
92431     try {
92432       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);
92433     } catch (std::out_of_range& e) {
92434       {
92435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92436       };
92437     } catch (std::exception& e) {
92438       {
92439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92440       };
92441     } catch (Dali::DaliException e) {
92442       {
92443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92444       };
92445     } catch (...) {
92446       {
92447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92448       };
92449     }
92450   }
92451
92452   jresult = (unsigned long)result;
92453   return jresult;
92454 }
92455
92456
92457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
92458   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92459   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92460
92461   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92462   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92463   {
92464     try {
92465       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
92466     } catch (std::out_of_range& e) {
92467       {
92468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92469       };
92470     } catch (std::exception& e) {
92471       {
92472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92473       };
92474     } catch (Dali::DaliException e) {
92475       {
92476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92477       };
92478     } catch (...) {
92479       {
92480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92481       };
92482     }
92483   }
92484
92485 }
92486
92487
92488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
92489   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92490   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
92491
92492   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92493   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
92494   {
92495     try {
92496       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92497     } catch (std::out_of_range& e) {
92498       {
92499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92500       };
92501     } catch (std::exception& e) {
92502       {
92503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92504       };
92505     } catch (Dali::DaliException e) {
92506       {
92507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92508       };
92509     } catch (...) {
92510       {
92511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92512       };
92513     }
92514   }
92515
92516 }
92517
92518
92519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92520   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92521   Dali::Toolkit::ProgressBar arg2 ;
92522   float arg3 ;
92523   float arg4 ;
92524   Dali::Toolkit::ProgressBar *argp2 ;
92525
92526   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92527   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92528   if (!argp2) {
92529     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92530     return ;
92531   }
92532   arg2 = *argp2;
92533   arg3 = (float)jarg3;
92534   arg4 = (float)jarg4;
92535   {
92536     try {
92537       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92538     } catch (std::out_of_range& e) {
92539       {
92540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92541       };
92542     } catch (std::exception& e) {
92543       {
92544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92545       };
92546     } catch (Dali::DaliException e) {
92547       {
92548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92549       };
92550     } catch (...) {
92551       {
92552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92553       };
92554     }
92555   }
92556
92557 }
92558
92559
92560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92561   void * jresult ;
92562   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92563
92564   {
92565     try {
92566       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92567     } catch (std::out_of_range& e) {
92568       {
92569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92570       };
92571     } catch (std::exception& e) {
92572       {
92573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92574       };
92575     } catch (Dali::DaliException e) {
92576       {
92577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92578       };
92579     } catch (...) {
92580       {
92581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92582       };
92583     }
92584   }
92585
92586   jresult = (void *)result;
92587   return jresult;
92588 }
92589
92590
92591 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92592   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92593
92594   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92595   {
92596     try {
92597       delete arg1;
92598     } catch (std::out_of_range& e) {
92599       {
92600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92601       };
92602     } catch (std::exception& e) {
92603       {
92604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92605       };
92606     } catch (Dali::DaliException e) {
92607       {
92608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92609       };
92610     } catch (...) {
92611       {
92612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92613       };
92614     }
92615   }
92616
92617 }
92618
92619
92620 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92621   unsigned int jresult ;
92622   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92623   bool result;
92624
92625   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92626   {
92627     try {
92628       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);
92629     } catch (std::out_of_range& e) {
92630       {
92631         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92632       };
92633     } catch (std::exception& e) {
92634       {
92635         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92636       };
92637     } catch (Dali::DaliException e) {
92638       {
92639         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92640       };
92641     } catch (...) {
92642       {
92643         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92644       };
92645     }
92646   }
92647
92648   jresult = result;
92649   return jresult;
92650 }
92651
92652
92653 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92654   unsigned long jresult ;
92655   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92656   std::size_t result;
92657
92658   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92659   {
92660     try {
92661       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);
92662     } catch (std::out_of_range& e) {
92663       {
92664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92665       };
92666     } catch (std::exception& e) {
92667       {
92668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92669       };
92670     } catch (Dali::DaliException e) {
92671       {
92672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92673       };
92674     } catch (...) {
92675       {
92676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92677       };
92678     }
92679   }
92680
92681   jresult = (unsigned long)result;
92682   return jresult;
92683 }
92684
92685
92686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92687   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92688   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92689
92690   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92691   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92692   {
92693     try {
92694       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92695     } catch (std::out_of_range& e) {
92696       {
92697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92698       };
92699     } catch (std::exception& e) {
92700       {
92701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92702       };
92703     } catch (Dali::DaliException e) {
92704       {
92705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92706       };
92707     } catch (...) {
92708       {
92709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92710       };
92711     }
92712   }
92713
92714 }
92715
92716
92717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92718   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92719   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92720
92721   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92722   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92723   {
92724     try {
92725       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92726     } catch (std::out_of_range& e) {
92727       {
92728         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92729       };
92730     } catch (std::exception& e) {
92731       {
92732         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92733       };
92734     } catch (Dali::DaliException e) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92737       };
92738     } catch (...) {
92739       {
92740         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92741       };
92742     }
92743   }
92744
92745 }
92746
92747
92748 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92749   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92750   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92751
92752   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92753   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92754   if (!arg2) {
92755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92756     return ;
92757   }
92758   {
92759     try {
92760       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92761     } catch (std::out_of_range& e) {
92762       {
92763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92764       };
92765     } catch (std::exception& e) {
92766       {
92767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92768       };
92769     } catch (Dali::DaliException e) {
92770       {
92771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92772       };
92773     } catch (...) {
92774       {
92775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92776       };
92777     }
92778   }
92779
92780 }
92781
92782
92783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92784   void * jresult ;
92785   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92786
92787   {
92788     try {
92789       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92790     } catch (std::out_of_range& e) {
92791       {
92792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92793       };
92794     } catch (std::exception& e) {
92795       {
92796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92797       };
92798     } catch (Dali::DaliException e) {
92799       {
92800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92801       };
92802     } catch (...) {
92803       {
92804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92805       };
92806     }
92807   }
92808
92809   jresult = (void *)result;
92810   return jresult;
92811 }
92812
92813
92814 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92815   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92816
92817   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92818   {
92819     try {
92820       delete arg1;
92821     } catch (std::out_of_range& e) {
92822       {
92823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92824       };
92825     } catch (std::exception& e) {
92826       {
92827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92828       };
92829     } catch (Dali::DaliException e) {
92830       {
92831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92832       };
92833     } catch (...) {
92834       {
92835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92836       };
92837     }
92838   }
92839
92840 }
92841
92842
92843 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92844   unsigned int jresult ;
92845   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92846   bool result;
92847
92848   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92849   {
92850     try {
92851       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92852     } catch (std::out_of_range& e) {
92853       {
92854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92855       };
92856     } catch (std::exception& e) {
92857       {
92858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92859       };
92860     } catch (Dali::DaliException e) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92863       };
92864     } catch (...) {
92865       {
92866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92867       };
92868     }
92869   }
92870
92871   jresult = result;
92872   return jresult;
92873 }
92874
92875
92876 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92877   unsigned long jresult ;
92878   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92879   std::size_t result;
92880
92881   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92882   {
92883     try {
92884       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92885     } catch (std::out_of_range& e) {
92886       {
92887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92888       };
92889     } catch (std::exception& e) {
92890       {
92891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92892       };
92893     } catch (Dali::DaliException e) {
92894       {
92895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92896       };
92897     } catch (...) {
92898       {
92899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92900       };
92901     }
92902   }
92903
92904   jresult = (unsigned long)result;
92905   return jresult;
92906 }
92907
92908
92909 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92910   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92911   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92912
92913   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92914   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92915   {
92916     try {
92917       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92918     } catch (std::out_of_range& e) {
92919       {
92920         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92921       };
92922     } catch (std::exception& e) {
92923       {
92924         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92925       };
92926     } catch (Dali::DaliException e) {
92927       {
92928         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92929       };
92930     } catch (...) {
92931       {
92932         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92933       };
92934     }
92935   }
92936
92937 }
92938
92939
92940 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92941   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92942   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92943
92944   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92945   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92946   {
92947     try {
92948       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92949     } catch (std::out_of_range& e) {
92950       {
92951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92952       };
92953     } catch (std::exception& e) {
92954       {
92955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92956       };
92957     } catch (Dali::DaliException e) {
92958       {
92959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92960       };
92961     } catch (...) {
92962       {
92963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92964       };
92965     }
92966   }
92967
92968 }
92969
92970
92971 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92972   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92973   Dali::Vector2 *arg2 = 0 ;
92974
92975   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92976   arg2 = (Dali::Vector2 *)jarg2;
92977   if (!arg2) {
92978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92979     return ;
92980   }
92981   {
92982     try {
92983       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92984     } catch (std::out_of_range& e) {
92985       {
92986         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92987       };
92988     } catch (std::exception& e) {
92989       {
92990         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92991       };
92992     } catch (Dali::DaliException e) {
92993       {
92994         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92995       };
92996     } catch (...) {
92997       {
92998         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92999       };
93000     }
93001   }
93002
93003 }
93004
93005
93006 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
93007   void * jresult ;
93008   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
93009
93010   {
93011     try {
93012       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
93013     } catch (std::out_of_range& e) {
93014       {
93015         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93016       };
93017     } catch (std::exception& e) {
93018       {
93019         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93020       };
93021     } catch (Dali::DaliException e) {
93022       {
93023         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93024       };
93025     } catch (...) {
93026       {
93027         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93028       };
93029     }
93030   }
93031
93032   jresult = (void *)result;
93033   return jresult;
93034 }
93035
93036
93037 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
93038   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
93039
93040   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
93041   {
93042     try {
93043       delete arg1;
93044     } catch (std::out_of_range& e) {
93045       {
93046         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93047       };
93048     } catch (std::exception& e) {
93049       {
93050         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93051       };
93052     } catch (Dali::DaliException e) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93055       };
93056     } catch (...) {
93057       {
93058         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93059       };
93060     }
93061   }
93062
93063 }
93064
93065
93066
93067 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
93068   unsigned int jresult ;
93069   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93070   bool result;
93071
93072   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93073   {
93074     try {
93075       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);
93076     } catch (std::out_of_range& e) {
93077       {
93078         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93079       };
93080     } catch (std::exception& e) {
93081       {
93082         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93083       };
93084     } catch (Dali::DaliException e) {
93085       {
93086         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93087       };
93088     } catch (...) {
93089       {
93090         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93091       };
93092     }
93093   }
93094
93095   jresult = result;
93096   return jresult;
93097 }
93098
93099
93100 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
93101   unsigned long jresult ;
93102   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93103   std::size_t result;
93104
93105   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93106   {
93107     try {
93108       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);
93109     } catch (std::out_of_range& e) {
93110       {
93111         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93112       };
93113     } catch (std::exception& e) {
93114       {
93115         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93116       };
93117     } catch (Dali::DaliException e) {
93118       {
93119         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93120       };
93121     } catch (...) {
93122       {
93123         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93124       };
93125     }
93126   }
93127
93128   jresult = (unsigned long)result;
93129   return jresult;
93130 }
93131
93132
93133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
93134   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93135   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93136
93137   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93138   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93139   {
93140     try {
93141       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
93142     } catch (std::out_of_range& e) {
93143       {
93144         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93145       };
93146     } catch (std::exception& e) {
93147       {
93148         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93149       };
93150     } catch (Dali::DaliException e) {
93151       {
93152         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93153       };
93154     } catch (...) {
93155       {
93156         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93157       };
93158     }
93159   }
93160
93161 }
93162
93163
93164 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
93165   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93166   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
93167
93168   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93169   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
93170   {
93171     try {
93172       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
93173     } catch (std::out_of_range& e) {
93174       {
93175         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93176       };
93177     } catch (std::exception& e) {
93178       {
93179         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93180       };
93181     } catch (Dali::DaliException e) {
93182       {
93183         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93184       };
93185     } catch (...) {
93186       {
93187         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93188       };
93189     }
93190   }
93191
93192 }
93193
93194
93195 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
93196   unsigned int jresult ;
93197   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93198   Dali::Toolkit::Control arg2 ;
93199   Dali::KeyEvent *arg3 = 0 ;
93200   Dali::Toolkit::Control *argp2 ;
93201   bool result;
93202
93203   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93204   argp2 = (Dali::Toolkit::Control *)jarg2;
93205   if (!argp2) {
93206     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93207     return 0;
93208   }
93209   arg2 = *argp2;
93210   arg3 = (Dali::KeyEvent *)jarg3;
93211   if (!arg3) {
93212     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
93213     return 0;
93214   }
93215   {
93216     try {
93217       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);
93218     } catch (std::out_of_range& e) {
93219       {
93220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93221       };
93222     } catch (std::exception& e) {
93223       {
93224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93225       };
93226     } catch (Dali::DaliException e) {
93227       {
93228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93229       };
93230     } catch (...) {
93231       {
93232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93233       };
93234     }
93235   }
93236
93237   jresult = result;
93238   return jresult;
93239 }
93240
93241
93242 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
93243   void * jresult ;
93244   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
93245
93246   {
93247     try {
93248       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
93249     } catch (std::out_of_range& e) {
93250       {
93251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93252       };
93253     } catch (std::exception& e) {
93254       {
93255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93256       };
93257     } catch (Dali::DaliException e) {
93258       {
93259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93260       };
93261     } catch (...) {
93262       {
93263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93264       };
93265     }
93266   }
93267
93268   jresult = (void *)result;
93269   return jresult;
93270 }
93271
93272
93273 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
93274   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
93275
93276   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
93277   {
93278     try {
93279       delete arg1;
93280     } catch (std::out_of_range& e) {
93281       {
93282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93283       };
93284     } catch (std::exception& e) {
93285       {
93286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93287       };
93288     } catch (Dali::DaliException e) {
93289       {
93290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93291       };
93292     } catch (...) {
93293       {
93294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93295       };
93296     }
93297   }
93298
93299 }
93300
93301
93302 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
93303   unsigned int jresult ;
93304   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93305   bool result;
93306
93307   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93308   {
93309     try {
93310       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93311     } catch (std::out_of_range& e) {
93312       {
93313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93314       };
93315     } catch (std::exception& e) {
93316       {
93317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93318       };
93319     } catch (Dali::DaliException e) {
93320       {
93321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93322       };
93323     } catch (...) {
93324       {
93325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93326       };
93327     }
93328   }
93329
93330   jresult = result;
93331   return jresult;
93332 }
93333
93334
93335 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
93336   unsigned long jresult ;
93337   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93338   std::size_t result;
93339
93340   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93341   {
93342     try {
93343       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
93344     } catch (std::out_of_range& e) {
93345       {
93346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93347       };
93348     } catch (std::exception& e) {
93349       {
93350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93351       };
93352     } catch (Dali::DaliException e) {
93353       {
93354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93355       };
93356     } catch (...) {
93357       {
93358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93359       };
93360     }
93361   }
93362
93363   jresult = (unsigned long)result;
93364   return jresult;
93365 }
93366
93367
93368 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
93369   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93370   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93371
93372   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93373   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93374   {
93375     try {
93376       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
93377     } catch (std::out_of_range& e) {
93378       {
93379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93380       };
93381     } catch (std::exception& e) {
93382       {
93383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93384       };
93385     } catch (Dali::DaliException e) {
93386       {
93387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93388       };
93389     } catch (...) {
93390       {
93391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93392       };
93393     }
93394   }
93395
93396 }
93397
93398
93399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
93400   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93401   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
93402
93403   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93404   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
93405   {
93406     try {
93407       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
93408     } catch (std::out_of_range& e) {
93409       {
93410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93411       };
93412     } catch (std::exception& e) {
93413       {
93414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93415       };
93416     } catch (Dali::DaliException e) {
93417       {
93418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93419       };
93420     } catch (...) {
93421       {
93422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93423       };
93424     }
93425   }
93426
93427 }
93428
93429
93430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
93431   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93432   Dali::Toolkit::Control arg2 ;
93433   Dali::Toolkit::Control *argp2 ;
93434
93435   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93436   argp2 = (Dali::Toolkit::Control *)jarg2;
93437   if (!argp2) {
93438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
93439     return ;
93440   }
93441   arg2 = *argp2;
93442   {
93443     try {
93444       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
93445     } catch (std::out_of_range& e) {
93446       {
93447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93448       };
93449     } catch (std::exception& e) {
93450       {
93451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93452       };
93453     } catch (Dali::DaliException e) {
93454       {
93455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93456       };
93457     } catch (...) {
93458       {
93459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93460       };
93461     }
93462   }
93463
93464 }
93465
93466
93467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusSignal() {
93468   void * jresult ;
93469   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
93470
93471   {
93472     try {
93473       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
93474     } catch (std::out_of_range& e) {
93475       {
93476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93477       };
93478     } catch (std::exception& e) {
93479       {
93480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93481       };
93482     } catch (Dali::DaliException e) {
93483       {
93484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93485       };
93486     } catch (...) {
93487       {
93488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93489       };
93490     }
93491   }
93492
93493   jresult = (void *)result;
93494   return jresult;
93495 }
93496
93497
93498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93499   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93500
93501   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93502   {
93503     try {
93504       delete arg1;
93505     } catch (std::out_of_range& e) {
93506       {
93507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93508       };
93509     } catch (std::exception& e) {
93510       {
93511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93512       };
93513     } catch (Dali::DaliException e) {
93514       {
93515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93516       };
93517     } catch (...) {
93518       {
93519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93520       };
93521     }
93522   }
93523
93524 }
93525
93526
93527 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93528   unsigned int jresult ;
93529   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93530   bool result;
93531
93532   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93533   {
93534     try {
93535       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93536     } catch (std::out_of_range& e) {
93537       {
93538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93539       };
93540     } catch (std::exception& e) {
93541       {
93542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93543       };
93544     } catch (Dali::DaliException e) {
93545       {
93546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93547       };
93548     } catch (...) {
93549       {
93550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93551       };
93552     }
93553   }
93554
93555   jresult = result;
93556   return jresult;
93557 }
93558
93559
93560 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93561   unsigned long jresult ;
93562   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93563   std::size_t result;
93564
93565   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93566   {
93567     try {
93568       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93569     } catch (std::out_of_range& e) {
93570       {
93571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93572       };
93573     } catch (std::exception& e) {
93574       {
93575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93576       };
93577     } catch (Dali::DaliException e) {
93578       {
93579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93580       };
93581     } catch (...) {
93582       {
93583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93584       };
93585     }
93586   }
93587
93588   jresult = (unsigned long)result;
93589   return jresult;
93590 }
93591
93592
93593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93594   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93595   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93596
93597   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93598   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93599   {
93600     try {
93601       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93602     } catch (std::out_of_range& e) {
93603       {
93604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93605       };
93606     } catch (std::exception& e) {
93607       {
93608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93609       };
93610     } catch (Dali::DaliException e) {
93611       {
93612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93613       };
93614     } catch (...) {
93615       {
93616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93617       };
93618     }
93619   }
93620
93621 }
93622
93623
93624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93625   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93626   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93627
93628   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93629   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93630   {
93631     try {
93632       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93633     } catch (std::out_of_range& e) {
93634       {
93635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93636       };
93637     } catch (std::exception& e) {
93638       {
93639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93640       };
93641     } catch (Dali::DaliException e) {
93642       {
93643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93644       };
93645     } catch (...) {
93646       {
93647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93648       };
93649     }
93650   }
93651
93652 }
93653
93654
93655 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93656   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93657   Dali::Toolkit::VideoView *arg2 = 0 ;
93658
93659   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93660   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93661   if (!arg2) {
93662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93663     return ;
93664   }
93665   {
93666     try {
93667       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93668     } catch (std::out_of_range& e) {
93669       {
93670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93671       };
93672     } catch (std::exception& e) {
93673       {
93674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93675       };
93676     } catch (Dali::DaliException e) {
93677       {
93678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93679       };
93680     } catch (...) {
93681       {
93682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93683       };
93684     }
93685   }
93686
93687 }
93688
93689
93690 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93691   void * jresult ;
93692   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93693
93694   {
93695     try {
93696       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93697     } catch (std::out_of_range& e) {
93698       {
93699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93700       };
93701     } catch (std::exception& e) {
93702       {
93703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93704       };
93705     } catch (Dali::DaliException e) {
93706       {
93707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93708       };
93709     } catch (...) {
93710       {
93711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93712       };
93713     }
93714   }
93715
93716   jresult = (void *)result;
93717   return jresult;
93718 }
93719
93720
93721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93722   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93723
93724   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93725   {
93726     try {
93727       delete arg1;
93728     } catch (std::out_of_range& e) {
93729       {
93730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93731       };
93732     } catch (std::exception& e) {
93733       {
93734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93735       };
93736     } catch (Dali::DaliException e) {
93737       {
93738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93739       };
93740     } catch (...) {
93741       {
93742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93743       };
93744     }
93745   }
93746
93747 }
93748
93749
93750 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93751   unsigned int jresult ;
93752   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93753   bool result;
93754
93755   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93756   {
93757     try {
93758       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93759     } catch (std::out_of_range& e) {
93760       {
93761         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93762       };
93763     } catch (std::exception& e) {
93764       {
93765         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93766       };
93767     } catch (Dali::DaliException e) {
93768       {
93769         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93770       };
93771     } catch (...) {
93772       {
93773         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93774       };
93775     }
93776   }
93777
93778   jresult = result;
93779   return jresult;
93780 }
93781
93782
93783 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93784   unsigned long jresult ;
93785   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93786   std::size_t result;
93787
93788   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93789   {
93790     try {
93791       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93792     } catch (std::out_of_range& e) {
93793       {
93794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93795       };
93796     } catch (std::exception& e) {
93797       {
93798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93799       };
93800     } catch (Dali::DaliException e) {
93801       {
93802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93803       };
93804     } catch (...) {
93805       {
93806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93807       };
93808     }
93809   }
93810
93811   jresult = (unsigned long)result;
93812   return jresult;
93813 }
93814
93815
93816 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93817   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93818   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93819
93820   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93821   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93822   {
93823     try {
93824       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93825     } catch (std::out_of_range& e) {
93826       {
93827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93828       };
93829     } catch (std::exception& e) {
93830       {
93831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93832       };
93833     } catch (Dali::DaliException e) {
93834       {
93835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93836       };
93837     } catch (...) {
93838       {
93839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93840       };
93841     }
93842   }
93843
93844 }
93845
93846
93847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93848   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93849   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93850
93851   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93852   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93853   {
93854     try {
93855       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93856     } catch (std::out_of_range& e) {
93857       {
93858         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93859       };
93860     } catch (std::exception& e) {
93861       {
93862         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93863       };
93864     } catch (Dali::DaliException e) {
93865       {
93866         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93867       };
93868     } catch (...) {
93869       {
93870         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93871       };
93872     }
93873   }
93874
93875 }
93876
93877
93878 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93879   unsigned int jresult ;
93880   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93881   Dali::Toolkit::Slider arg2 ;
93882   float arg3 ;
93883   Dali::Toolkit::Slider *argp2 ;
93884   bool result;
93885
93886   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93887   argp2 = (Dali::Toolkit::Slider *)jarg2;
93888   if (!argp2) {
93889     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93890     return 0;
93891   }
93892   arg2 = *argp2;
93893   arg3 = (float)jarg3;
93894   {
93895     try {
93896       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93897     } catch (std::out_of_range& e) {
93898       {
93899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93900       };
93901     } catch (std::exception& e) {
93902       {
93903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93904       };
93905     } catch (Dali::DaliException e) {
93906       {
93907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93908       };
93909     } catch (...) {
93910       {
93911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93912       };
93913     }
93914   }
93915
93916   jresult = result;
93917   return jresult;
93918 }
93919
93920
93921 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93922   void * jresult ;
93923   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93924
93925   {
93926     try {
93927       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93928     } catch (std::out_of_range& e) {
93929       {
93930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93931       };
93932     } catch (std::exception& e) {
93933       {
93934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93935       };
93936     } catch (Dali::DaliException e) {
93937       {
93938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93939       };
93940     } catch (...) {
93941       {
93942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93943       };
93944     }
93945   }
93946
93947   jresult = (void *)result;
93948   return jresult;
93949 }
93950
93951
93952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93953   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93954
93955   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93956   {
93957     try {
93958       delete arg1;
93959     } catch (std::out_of_range& e) {
93960       {
93961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93962       };
93963     } catch (std::exception& e) {
93964       {
93965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93966       };
93967     } catch (Dali::DaliException e) {
93968       {
93969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93970       };
93971     } catch (...) {
93972       {
93973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93974       };
93975     }
93976   }
93977
93978 }
93979
93980
93981 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93982   unsigned int jresult ;
93983   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93984   bool result;
93985
93986   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93987   {
93988     try {
93989       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93990     } catch (std::out_of_range& e) {
93991       {
93992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93993       };
93994     } catch (std::exception& e) {
93995       {
93996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93997       };
93998     } catch (Dali::DaliException e) {
93999       {
94000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94001       };
94002     } catch (...) {
94003       {
94004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94005       };
94006     }
94007   }
94008
94009   jresult = result;
94010   return jresult;
94011 }
94012
94013
94014 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
94015   unsigned long jresult ;
94016   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94017   std::size_t result;
94018
94019   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94020   {
94021     try {
94022       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
94023     } catch (std::out_of_range& e) {
94024       {
94025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94026       };
94027     } catch (std::exception& e) {
94028       {
94029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94030       };
94031     } catch (Dali::DaliException e) {
94032       {
94033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94034       };
94035     } catch (...) {
94036       {
94037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94038       };
94039     }
94040   }
94041
94042   jresult = (unsigned long)result;
94043   return jresult;
94044 }
94045
94046
94047 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
94048   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94049   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94050
94051   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94052   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94053   {
94054     try {
94055       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
94056     } catch (std::out_of_range& e) {
94057       {
94058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94059       };
94060     } catch (std::exception& e) {
94061       {
94062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94063       };
94064     } catch (Dali::DaliException e) {
94065       {
94066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94067       };
94068     } catch (...) {
94069       {
94070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94071       };
94072     }
94073   }
94074
94075 }
94076
94077
94078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
94079   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94080   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
94081
94082   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94083   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
94084   {
94085     try {
94086       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
94087     } catch (std::out_of_range& e) {
94088       {
94089         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94090       };
94091     } catch (std::exception& e) {
94092       {
94093         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94094       };
94095     } catch (Dali::DaliException e) {
94096       {
94097         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94098       };
94099     } catch (...) {
94100       {
94101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94102       };
94103     }
94104   }
94105
94106 }
94107
94108
94109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
94110   unsigned int jresult ;
94111   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94112   Dali::Toolkit::Slider arg2 ;
94113   int arg3 ;
94114   Dali::Toolkit::Slider *argp2 ;
94115   bool result;
94116
94117   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94118   argp2 = (Dali::Toolkit::Slider *)jarg2;
94119   if (!argp2) {
94120     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
94121     return 0;
94122   }
94123   arg2 = *argp2;
94124   arg3 = (int)jarg3;
94125   {
94126     try {
94127       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
94128     } catch (std::out_of_range& e) {
94129       {
94130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94131       };
94132     } catch (std::exception& e) {
94133       {
94134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94135       };
94136     } catch (Dali::DaliException e) {
94137       {
94138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94139       };
94140     } catch (...) {
94141       {
94142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94143       };
94144     }
94145   }
94146
94147   jresult = result;
94148   return jresult;
94149 }
94150
94151
94152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
94153   void * jresult ;
94154   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
94155
94156   {
94157     try {
94158       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
94159     } catch (std::out_of_range& e) {
94160       {
94161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94162       };
94163     } catch (std::exception& e) {
94164       {
94165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94166       };
94167     } catch (Dali::DaliException e) {
94168       {
94169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94170       };
94171     } catch (...) {
94172       {
94173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94174       };
94175     }
94176   }
94177
94178   jresult = (void *)result;
94179   return jresult;
94180 }
94181
94182
94183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
94184   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
94185
94186   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
94187   {
94188     try {
94189       delete arg1;
94190     } catch (std::out_of_range& e) {
94191       {
94192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94193       };
94194     } catch (std::exception& e) {
94195       {
94196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94197       };
94198     } catch (Dali::DaliException e) {
94199       {
94200         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94201       };
94202     } catch (...) {
94203       {
94204         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94205       };
94206     }
94207   }
94208
94209 }
94210
94211
94212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
94213   void * jresult ;
94214   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94215
94216   {
94217     try {
94218       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
94219     } catch (std::out_of_range& e) {
94220       {
94221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94222       };
94223     } catch (std::exception& e) {
94224       {
94225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94226       };
94227     } catch (Dali::DaliException e) {
94228       {
94229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94230       };
94231     } catch (...) {
94232       {
94233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94234       };
94235     }
94236   }
94237
94238   jresult = (void *)result;
94239   return jresult;
94240 }
94241
94242
94243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
94244   void * jresult ;
94245   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
94246   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94247
94248   arg1 = (Dali::Toolkit::Ruler *)jarg1;
94249   {
94250     try {
94251       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
94252     } catch (std::out_of_range& e) {
94253       {
94254         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94255       };
94256     } catch (std::exception& e) {
94257       {
94258         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94259       };
94260     } catch (Dali::DaliException e) {
94261       {
94262         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94263       };
94264     } catch (...) {
94265       {
94266         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94267       };
94268     }
94269   }
94270
94271   jresult = (void *)result;
94272   return jresult;
94273 }
94274
94275
94276 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
94277   void * jresult ;
94278   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
94279   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94280
94281   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94282   if (!arg1) {
94283     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94284     return 0;
94285   }
94286   {
94287     try {
94288       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
94289     } catch (std::out_of_range& e) {
94290       {
94291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94292       };
94293     } catch (std::exception& e) {
94294       {
94295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94296       };
94297     } catch (Dali::DaliException e) {
94298       {
94299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94300       };
94301     } catch (...) {
94302       {
94303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94304       };
94305     }
94306   }
94307
94308   jresult = (void *)result;
94309   return jresult;
94310 }
94311
94312
94313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
94314   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94315
94316   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94317   {
94318     try {
94319       delete arg1;
94320     } catch (std::out_of_range& e) {
94321       {
94322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94323       };
94324     } catch (std::exception& e) {
94325       {
94326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94327       };
94328     } catch (Dali::DaliException e) {
94329       {
94330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94331       };
94332     } catch (...) {
94333       {
94334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94335       };
94336     }
94337   }
94338
94339 }
94340
94341
94342 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
94343   void * jresult ;
94344   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94345   Dali::Toolkit::Ruler *result = 0 ;
94346
94347   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94348   {
94349     try {
94350       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
94351     } catch (std::out_of_range& e) {
94352       {
94353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94354       };
94355     } catch (std::exception& e) {
94356       {
94357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94358       };
94359     } catch (Dali::DaliException e) {
94360       {
94361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94362       };
94363     } catch (...) {
94364       {
94365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94366       };
94367     }
94368   }
94369
94370   jresult = (void *)result;
94371   return jresult;
94372 }
94373
94374
94375 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
94376   void * jresult ;
94377   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94378   Dali::Toolkit::Ruler *result = 0 ;
94379
94380   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94381   {
94382     try {
94383       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
94384     } catch (std::out_of_range& e) {
94385       {
94386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94387       };
94388     } catch (std::exception& e) {
94389       {
94390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94391       };
94392     } catch (Dali::DaliException e) {
94393       {
94394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94395       };
94396     } catch (...) {
94397       {
94398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94399       };
94400     }
94401   }
94402
94403   jresult = (void *)result;
94404   return jresult;
94405 }
94406
94407
94408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
94409   void * jresult ;
94410   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94411   Dali::Toolkit::Ruler *result = 0 ;
94412
94413   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94414   {
94415     try {
94416       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
94417     } catch (std::out_of_range& e) {
94418       {
94419         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94420       };
94421     } catch (std::exception& e) {
94422       {
94423         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94424       };
94425     } catch (Dali::DaliException e) {
94426       {
94427         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94428       };
94429     } catch (...) {
94430       {
94431         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94432       };
94433     }
94434   }
94435
94436   jresult = (void *)result;
94437   return jresult;
94438 }
94439
94440
94441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
94442   void * jresult ;
94443   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94444   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
94445   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94446
94447   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94448   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
94449   if (!arg2) {
94450     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
94451     return 0;
94452   }
94453   {
94454     try {
94455       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
94456     } catch (std::out_of_range& e) {
94457       {
94458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94459       };
94460     } catch (std::exception& e) {
94461       {
94462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94463       };
94464     } catch (Dali::DaliException e) {
94465       {
94466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94467       };
94468     } catch (...) {
94469       {
94470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94471       };
94472     }
94473   }
94474
94475   jresult = (void *)result;
94476   return jresult;
94477 }
94478
94479
94480 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
94481   void * jresult ;
94482   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94483   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94484   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
94485
94486   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94487   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94488   {
94489     try {
94490       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
94491     } catch (std::out_of_range& e) {
94492       {
94493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94494       };
94495     } catch (std::exception& e) {
94496       {
94497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94498       };
94499     } catch (Dali::DaliException e) {
94500       {
94501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94502       };
94503     } catch (...) {
94504       {
94505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94506       };
94507     }
94508   }
94509
94510   jresult = (void *)result;
94511   return jresult;
94512 }
94513
94514
94515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94516   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94517
94518   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94519   {
94520     try {
94521       (arg1)->Reset();
94522     } catch (std::out_of_range& e) {
94523       {
94524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94525       };
94526     } catch (std::exception& e) {
94527       {
94528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94529       };
94530     } catch (Dali::DaliException e) {
94531       {
94532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94533       };
94534     } catch (...) {
94535       {
94536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94537       };
94538     }
94539   }
94540
94541 }
94542
94543
94544 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94545   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94546   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94547
94548   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94549   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94550   {
94551     try {
94552       (arg1)->Reset(arg2);
94553     } catch (std::out_of_range& e) {
94554       {
94555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94556       };
94557     } catch (std::exception& e) {
94558       {
94559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94560       };
94561     } catch (Dali::DaliException e) {
94562       {
94563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94564       };
94565     } catch (...) {
94566       {
94567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94568       };
94569     }
94570   }
94571
94572 }
94573
94574
94575 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94576   void * jresult ;
94577   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94578   Dali::Toolkit::Ruler *result = 0 ;
94579
94580   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94581   {
94582     try {
94583       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94584     } catch (std::out_of_range& e) {
94585       {
94586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94587       };
94588     } catch (std::exception& e) {
94589       {
94590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94591       };
94592     } catch (Dali::DaliException e) {
94593       {
94594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94595       };
94596     } catch (...) {
94597       {
94598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94599       };
94600     }
94601   }
94602
94603   jresult = (void *)result;
94604   return jresult;
94605 }
94606
94607
94608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94609   float jresult ;
94610   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94611   float arg2 ;
94612   float arg3 ;
94613   float result;
94614
94615   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94616   arg2 = (float)jarg2;
94617   arg3 = (float)jarg3;
94618   {
94619     try {
94620       result = (float)(*arg1)->Snap(arg2,arg3);
94621     } catch (std::out_of_range& e) {
94622       {
94623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94624       };
94625     } catch (std::exception& e) {
94626       {
94627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94628       };
94629     } catch (Dali::DaliException e) {
94630       {
94631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94632       };
94633     } catch (...) {
94634       {
94635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94636       };
94637     }
94638   }
94639
94640   jresult = result;
94641   return jresult;
94642 }
94643
94644
94645 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94646   float jresult ;
94647   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94648   float arg2 ;
94649   float result;
94650
94651   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94652   arg2 = (float)jarg2;
94653   {
94654     try {
94655       result = (float)(*arg1)->Snap(arg2);
94656     } catch (std::out_of_range& e) {
94657       {
94658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94659       };
94660     } catch (std::exception& e) {
94661       {
94662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94663       };
94664     } catch (Dali::DaliException e) {
94665       {
94666         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94667       };
94668     } catch (...) {
94669       {
94670         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94671       };
94672     }
94673   }
94674
94675   jresult = result;
94676   return jresult;
94677 }
94678
94679
94680 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94681   float jresult ;
94682   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94683   unsigned int arg2 ;
94684   unsigned int *arg3 = 0 ;
94685   bool arg4 ;
94686   float result;
94687
94688   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94689   arg2 = (unsigned int)jarg2;
94690   arg3 = (unsigned int *)jarg3;
94691   arg4 = jarg4 ? true : false;
94692   {
94693     try {
94694       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94695     } catch (std::out_of_range& e) {
94696       {
94697         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94698       };
94699     } catch (std::exception& e) {
94700       {
94701         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94702       };
94703     } catch (Dali::DaliException e) {
94704       {
94705         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94706       };
94707     } catch (...) {
94708       {
94709         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94710       };
94711     }
94712   }
94713
94714   jresult = result;
94715   return jresult;
94716 }
94717
94718
94719 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94720   unsigned int jresult ;
94721   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94722   float arg2 ;
94723   bool arg3 ;
94724   unsigned int result;
94725
94726   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94727   arg2 = (float)jarg2;
94728   arg3 = jarg3 ? true : false;
94729   {
94730     try {
94731       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94732     } catch (std::out_of_range& e) {
94733       {
94734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94735       };
94736     } catch (std::exception& e) {
94737       {
94738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94739       };
94740     } catch (Dali::DaliException e) {
94741       {
94742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94743       };
94744     } catch (...) {
94745       {
94746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94747       };
94748     }
94749   }
94750
94751   jresult = result;
94752   return jresult;
94753 }
94754
94755
94756 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94757   unsigned int jresult ;
94758   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94759   unsigned int result;
94760
94761   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94762   {
94763     try {
94764       result = (unsigned int)(*arg1)->GetTotalPages();
94765     } catch (std::out_of_range& e) {
94766       {
94767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94768       };
94769     } catch (std::exception& e) {
94770       {
94771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94772       };
94773     } catch (Dali::DaliException e) {
94774       {
94775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94776       };
94777     } catch (...) {
94778       {
94779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94780       };
94781     }
94782   }
94783
94784   jresult = result;
94785   return jresult;
94786 }
94787
94788
94789 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94790   int jresult ;
94791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94792   Dali::Toolkit::Ruler::RulerType result;
94793
94794   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94795   {
94796     try {
94797       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94798     } catch (std::out_of_range& e) {
94799       {
94800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94801       };
94802     } catch (std::exception& e) {
94803       {
94804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94805       };
94806     } catch (Dali::DaliException e) {
94807       {
94808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94809       };
94810     } catch (...) {
94811       {
94812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94813       };
94814     }
94815   }
94816
94817   jresult = (int)result;
94818   return jresult;
94819 }
94820
94821
94822 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94823   unsigned int jresult ;
94824   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94825   bool result;
94826
94827   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94828   {
94829     try {
94830       result = (bool)(*arg1)->IsEnabled();
94831     } catch (std::out_of_range& e) {
94832       {
94833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94834       };
94835     } catch (std::exception& e) {
94836       {
94837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94838       };
94839     } catch (Dali::DaliException e) {
94840       {
94841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94842       };
94843     } catch (...) {
94844       {
94845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94846       };
94847     }
94848   }
94849
94850   jresult = result;
94851   return jresult;
94852 }
94853
94854
94855 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94856   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94857
94858   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94859   {
94860     try {
94861       (*arg1)->Enable();
94862     } catch (std::out_of_range& e) {
94863       {
94864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94865       };
94866     } catch (std::exception& e) {
94867       {
94868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94869       };
94870     } catch (Dali::DaliException e) {
94871       {
94872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94873       };
94874     } catch (...) {
94875       {
94876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94877       };
94878     }
94879   }
94880
94881 }
94882
94883
94884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94885   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94886
94887   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94888   {
94889     try {
94890       (*arg1)->Disable();
94891     } catch (std::out_of_range& e) {
94892       {
94893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94894       };
94895     } catch (std::exception& e) {
94896       {
94897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94898       };
94899     } catch (Dali::DaliException e) {
94900       {
94901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94902       };
94903     } catch (...) {
94904       {
94905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94906       };
94907     }
94908   }
94909
94910 }
94911
94912
94913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94914   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94915   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94916   Dali::Toolkit::RulerDomain *argp2 ;
94917
94918   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94919   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94920   if (!argp2) {
94921     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94922     return ;
94923   }
94924   arg2 = *argp2;
94925   {
94926     try {
94927       (*arg1)->SetDomain(arg2);
94928     } catch (std::out_of_range& e) {
94929       {
94930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94931       };
94932     } catch (std::exception& e) {
94933       {
94934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94935       };
94936     } catch (Dali::DaliException e) {
94937       {
94938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94939       };
94940     } catch (...) {
94941       {
94942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94943       };
94944     }
94945   }
94946
94947 }
94948
94949
94950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94951   void * jresult ;
94952   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94953   Dali::Toolkit::RulerDomain *result = 0 ;
94954
94955   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94956   {
94957     try {
94958       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94959     } catch (std::out_of_range& e) {
94960       {
94961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94962       };
94963     } catch (std::exception& e) {
94964       {
94965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94966       };
94967     } catch (Dali::DaliException e) {
94968       {
94969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94970       };
94971     } catch (...) {
94972       {
94973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94974       };
94975     }
94976   }
94977
94978   jresult = (void *)result;
94979   return jresult;
94980 }
94981
94982
94983 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94984   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94985
94986   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94987   {
94988     try {
94989       (*arg1)->DisableDomain();
94990     } catch (std::out_of_range& e) {
94991       {
94992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94993       };
94994     } catch (std::exception& e) {
94995       {
94996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94997       };
94998     } catch (Dali::DaliException e) {
94999       {
95000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95001       };
95002     } catch (...) {
95003       {
95004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95005       };
95006     }
95007   }
95008
95009 }
95010
95011
95012 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
95013   float jresult ;
95014   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95015   float arg2 ;
95016   float arg3 ;
95017   float arg4 ;
95018   float result;
95019
95020   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95021   arg2 = (float)jarg2;
95022   arg3 = (float)jarg3;
95023   arg4 = (float)jarg4;
95024   {
95025     try {
95026       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
95027     } catch (std::out_of_range& e) {
95028       {
95029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95030       };
95031     } catch (std::exception& e) {
95032       {
95033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95034       };
95035     } catch (Dali::DaliException e) {
95036       {
95037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95038       };
95039     } catch (...) {
95040       {
95041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95042       };
95043     }
95044   }
95045
95046   jresult = result;
95047   return jresult;
95048 }
95049
95050
95051 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
95052   float jresult ;
95053   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95054   float arg2 ;
95055   float arg3 ;
95056   float result;
95057
95058   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95059   arg2 = (float)jarg2;
95060   arg3 = (float)jarg3;
95061   {
95062     try {
95063       result = (float)(*arg1)->Clamp(arg2,arg3);
95064     } catch (std::out_of_range& e) {
95065       {
95066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95067       };
95068     } catch (std::exception& e) {
95069       {
95070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95071       };
95072     } catch (Dali::DaliException e) {
95073       {
95074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95075       };
95076     } catch (...) {
95077       {
95078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95079       };
95080     }
95081   }
95082
95083   jresult = result;
95084   return jresult;
95085 }
95086
95087
95088 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
95089   float jresult ;
95090   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95091   float arg2 ;
95092   float result;
95093
95094   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95095   arg2 = (float)jarg2;
95096   {
95097     try {
95098       result = (float)(*arg1)->Clamp(arg2);
95099     } catch (std::out_of_range& e) {
95100       {
95101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95102       };
95103     } catch (std::exception& e) {
95104       {
95105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95106       };
95107     } catch (Dali::DaliException e) {
95108       {
95109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95110       };
95111     } catch (...) {
95112       {
95113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95114       };
95115     }
95116   }
95117
95118   jresult = result;
95119   return jresult;
95120 }
95121
95122
95123 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
95124   float jresult ;
95125   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95126   float arg2 ;
95127   float arg3 ;
95128   float arg4 ;
95129   Dali::Toolkit::ClampState *arg5 = 0 ;
95130   float result;
95131
95132   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95133   arg2 = (float)jarg2;
95134   arg3 = (float)jarg3;
95135   arg4 = (float)jarg4;
95136   arg5 = (Dali::Toolkit::ClampState *)jarg5;
95137   if (!arg5) {
95138     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95139     return 0;
95140   }
95141   {
95142     try {
95143       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
95144     } catch (std::out_of_range& e) {
95145       {
95146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95147       };
95148     } catch (std::exception& e) {
95149       {
95150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95151       };
95152     } catch (Dali::DaliException e) {
95153       {
95154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95155       };
95156     } catch (...) {
95157       {
95158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95159       };
95160     }
95161   }
95162
95163   jresult = result;
95164   return jresult;
95165 }
95166
95167
95168 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
95169   float jresult ;
95170   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95171   float arg2 ;
95172   float arg3 ;
95173   float arg4 ;
95174   float arg5 ;
95175   float result;
95176
95177   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95178   arg2 = (float)jarg2;
95179   arg3 = (float)jarg3;
95180   arg4 = (float)jarg4;
95181   arg5 = (float)jarg5;
95182   {
95183     try {
95184       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
95185     } catch (std::out_of_range& e) {
95186       {
95187         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95188       };
95189     } catch (std::exception& e) {
95190       {
95191         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95192       };
95193     } catch (Dali::DaliException e) {
95194       {
95195         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95196       };
95197     } catch (...) {
95198       {
95199         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95200       };
95201     }
95202   }
95203
95204   jresult = result;
95205   return jresult;
95206 }
95207
95208
95209 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
95210   float jresult ;
95211   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95212   float arg2 ;
95213   float arg3 ;
95214   float arg4 ;
95215   float result;
95216
95217   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95218   arg2 = (float)jarg2;
95219   arg3 = (float)jarg3;
95220   arg4 = (float)jarg4;
95221   {
95222     try {
95223       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
95224     } catch (std::out_of_range& e) {
95225       {
95226         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95227       };
95228     } catch (std::exception& e) {
95229       {
95230         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95231       };
95232     } catch (Dali::DaliException e) {
95233       {
95234         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95235       };
95236     } catch (...) {
95237       {
95238         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95239       };
95240     }
95241   }
95242
95243   jresult = result;
95244   return jresult;
95245 }
95246
95247
95248 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
95249   float jresult ;
95250   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95251   float arg2 ;
95252   float arg3 ;
95253   float result;
95254
95255   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95256   arg2 = (float)jarg2;
95257   arg3 = (float)jarg3;
95258   {
95259     try {
95260       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
95261     } catch (std::out_of_range& e) {
95262       {
95263         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95264       };
95265     } catch (std::exception& e) {
95266       {
95267         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95268       };
95269     } catch (Dali::DaliException e) {
95270       {
95271         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95272       };
95273     } catch (...) {
95274       {
95275         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95276       };
95277     }
95278   }
95279
95280   jresult = result;
95281   return jresult;
95282 }
95283
95284
95285 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
95286   float jresult ;
95287   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95288   float arg2 ;
95289   float result;
95290
95291   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95292   arg2 = (float)jarg2;
95293   {
95294     try {
95295       result = (float)(*arg1)->SnapAndClamp(arg2);
95296     } catch (std::out_of_range& e) {
95297       {
95298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95299       };
95300     } catch (std::exception& e) {
95301       {
95302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95303       };
95304     } catch (Dali::DaliException e) {
95305       {
95306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95307       };
95308     } catch (...) {
95309       {
95310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95311       };
95312     }
95313   }
95314
95315   jresult = result;
95316   return jresult;
95317 }
95318
95319
95320 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
95321   float jresult ;
95322   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95323   float arg2 ;
95324   float arg3 ;
95325   float arg4 ;
95326   float arg5 ;
95327   Dali::Toolkit::ClampState *arg6 = 0 ;
95328   float result;
95329
95330   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95331   arg2 = (float)jarg2;
95332   arg3 = (float)jarg3;
95333   arg4 = (float)jarg4;
95334   arg5 = (float)jarg5;
95335   arg6 = (Dali::Toolkit::ClampState *)jarg6;
95336   if (!arg6) {
95337     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
95338     return 0;
95339   }
95340   {
95341     try {
95342       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
95343     } catch (std::out_of_range& e) {
95344       {
95345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95346       };
95347     } catch (std::exception& e) {
95348       {
95349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95350       };
95351     } catch (Dali::DaliException e) {
95352       {
95353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95354       };
95355     } catch (...) {
95356       {
95357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95358       };
95359     }
95360   }
95361
95362   jresult = result;
95363   return jresult;
95364 }
95365
95366
95367 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
95368   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95369
95370   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95371   {
95372     try {
95373       (*arg1)->Reference();
95374     } catch (std::out_of_range& e) {
95375       {
95376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95377       };
95378     } catch (std::exception& e) {
95379       {
95380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95381       };
95382     } catch (Dali::DaliException e) {
95383       {
95384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95385       };
95386     } catch (...) {
95387       {
95388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95389       };
95390     }
95391   }
95392
95393 }
95394
95395
95396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
95397   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95398
95399   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95400   {
95401     try {
95402       (*arg1)->Unreference();
95403     } catch (std::out_of_range& e) {
95404       {
95405         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95406       };
95407     } catch (std::exception& e) {
95408       {
95409         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95410       };
95411     } catch (Dali::DaliException e) {
95412       {
95413         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95414       };
95415     } catch (...) {
95416       {
95417         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95418       };
95419     }
95420   }
95421
95422 }
95423
95424
95425 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
95426   int jresult ;
95427   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
95428   int result;
95429
95430   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
95431   {
95432     try {
95433       result = (int)(*arg1)->ReferenceCount();
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 = result;
95454   return jresult;
95455 }
95456
95457
95458 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
95459   unsigned int jresult ;
95460   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95461   bool result;
95462
95463   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95464   {
95465     try {
95466       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95467     } catch (std::out_of_range& e) {
95468       {
95469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95470       };
95471     } catch (std::exception& e) {
95472       {
95473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95474       };
95475     } catch (Dali::DaliException e) {
95476       {
95477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95478       };
95479     } catch (...) {
95480       {
95481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95482       };
95483     }
95484   }
95485
95486   jresult = result;
95487   return jresult;
95488 }
95489
95490
95491 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
95492   unsigned long jresult ;
95493   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95494   std::size_t result;
95495
95496   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95497   {
95498     try {
95499       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95500     } catch (std::out_of_range& e) {
95501       {
95502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95503       };
95504     } catch (std::exception& e) {
95505       {
95506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95507       };
95508     } catch (Dali::DaliException e) {
95509       {
95510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95511       };
95512     } catch (...) {
95513       {
95514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95515       };
95516     }
95517   }
95518
95519   jresult = (unsigned long)result;
95520   return jresult;
95521 }
95522
95523
95524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95525   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95526   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95527
95528   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95529   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95530   {
95531     try {
95532       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,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_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95556   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95557   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95558
95559   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95560   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95561   {
95562     try {
95563       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95564     } catch (std::out_of_range& e) {
95565       {
95566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95567       };
95568     } catch (std::exception& e) {
95569       {
95570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95571       };
95572     } catch (Dali::DaliException e) {
95573       {
95574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95575       };
95576     } catch (...) {
95577       {
95578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95579       };
95580     }
95581   }
95582
95583 }
95584
95585
95586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95587   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95588   Dali::Toolkit::Control arg2 ;
95589   Dali::Toolkit::Control *argp2 ;
95590
95591   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95592   argp2 = (Dali::Toolkit::Control *)jarg2;
95593   if (!argp2) {
95594     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95595     return ;
95596   }
95597   arg2 = *argp2;
95598   {
95599     try {
95600       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95601     } catch (std::out_of_range& e) {
95602       {
95603         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95604       };
95605     } catch (std::exception& e) {
95606       {
95607         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95608       };
95609     } catch (Dali::DaliException e) {
95610       {
95611         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95612       };
95613     } catch (...) {
95614       {
95615         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95616       };
95617     }
95618   }
95619
95620 }
95621
95622
95623 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95624   void * jresult ;
95625   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95626
95627   {
95628     try {
95629       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95630     } catch (std::out_of_range& e) {
95631       {
95632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95633       };
95634     } catch (std::exception& e) {
95635       {
95636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95637       };
95638     } catch (Dali::DaliException e) {
95639       {
95640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95641       };
95642     } catch (...) {
95643       {
95644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95645       };
95646     }
95647   }
95648
95649   jresult = (void *)result;
95650   return jresult;
95651 }
95652
95653
95654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95655   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95656
95657   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95658   {
95659     try {
95660       delete arg1;
95661     } catch (std::out_of_range& e) {
95662       {
95663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95664       };
95665     } catch (std::exception& e) {
95666       {
95667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95668       };
95669     } catch (Dali::DaliException e) {
95670       {
95671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95672       };
95673     } catch (...) {
95674       {
95675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95676       };
95677     }
95678   }
95679
95680 }
95681
95682 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95683   Dali::RefObject *result = NULL;
95684
95685   if (arg1)
95686   {
95687     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95688   }
95689   return result;
95690 }
95691
95692 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95693     return (Dali::RefObject *)jarg1;
95694 }
95695
95696 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95697     return (Dali::SignalObserver *)jarg1;
95698 }
95699
95700 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95701     return (Dali::ConnectionTrackerInterface *)jarg1;
95702 }
95703
95704 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95705     return (Dali::BaseHandle *)jarg1;
95706 }
95707
95708 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95709     return (Dali::BaseHandle *)jarg1;
95710 }
95711
95712 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95713     return (Dali::BaseHandle *)jarg1;
95714 }
95715
95716 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95717     return (Dali::BaseHandle *)jarg1;
95718 }
95719
95720 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95721     return (Dali::BaseHandle *)jarg1;
95722 }
95723
95724 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95725     return (Dali::BaseHandle *)jarg1;
95726 }
95727
95728 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95729     return (Dali::BaseHandle *)jarg1;
95730 }
95731
95732 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95733     return (Dali::BaseHandle *)jarg1;
95734 }
95735
95736 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95737     return (Dali::BaseHandle *)jarg1;
95738 }
95739
95740 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95741     return (Dali::BaseHandle *)jarg1;
95742 }
95743
95744 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95745     return (Dali::BaseHandle *)jarg1;
95746 }
95747
95748 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95749     return (Dali::BaseHandle *)jarg1;
95750 }
95751
95752 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95753     return (Dali::Handle *)jarg1;
95754 }
95755
95756 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95757     return (Dali::Handle *)jarg1;
95758 }
95759
95760 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95761     return (Dali::BaseHandle *)jarg1;
95762 }
95763
95764 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95765     return (Dali::BaseHandle *)jarg1;
95766 }
95767
95768 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95769     return (Dali::Handle *)jarg1;
95770 }
95771
95772 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
95773     return (Dali::BaseHandle *)jarg1;
95774 }
95775
95776 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95777     return (Dali::Handle *)jarg1;
95778 }
95779
95780 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95781     return (Dali::GestureDetector *)jarg1;
95782 }
95783
95784 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95785     return (Dali::Gesture *)jarg1;
95786 }
95787
95788 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95789     return (Dali::Handle *)jarg1;
95790 }
95791
95792 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95793     return (Dali::Actor *)jarg1;
95794 }
95795
95796 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Stage_SWIGUpcast(Dali::Stage *jarg1) {
95797     return (Dali::BaseHandle *)jarg1;
95798 }
95799
95800 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95801     return (Dali::RefObject *)jarg1;
95802 }
95803
95804 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95805     return (Dali::Actor *)jarg1;
95806 }
95807
95808 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95809     return (Dali::GestureDetector *)jarg1;
95810 }
95811
95812 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95813     return (Dali::Gesture *)jarg1;
95814 }
95815
95816 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95817     return (Dali::GestureDetector *)jarg1;
95818 }
95819
95820 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95821     return (Dali::Gesture *)jarg1;
95822 }
95823
95824 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95825     return (Dali::GestureDetector *)jarg1;
95826 }
95827
95828 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95829     return (Dali::Gesture *)jarg1;
95830 }
95831
95832 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95833     return (Dali::BaseHandle *)jarg1;
95834 }
95835
95836 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95837     return (Dali::Handle *)jarg1;
95838 }
95839
95840 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95841     return (Dali::Handle *)jarg1;
95842 }
95843
95844 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95845     return (Dali::Handle *)jarg1;
95846 }
95847
95848 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95849     return (Dali::RefObject *)jarg1;
95850 }
95851
95852 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95853     return (Dali::Actor *)jarg1;
95854 }
95855
95856 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95857     return (Dali::BaseHandle *)jarg1;
95858 }
95859
95860 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95861     return (Dali::BaseHandle *)jarg1;
95862 }
95863
95864 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95865     return (Dali::BaseHandle *)jarg1;
95866 }
95867
95868 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95869     return (Dali::CustomActorImpl *)jarg1;
95870 }
95871
95872 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95873     return (Dali::CustomActor *)jarg1;
95874 }
95875
95876 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95877     return (Dali::BaseHandle *)jarg1;
95878 }
95879
95880 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95881     return (Dali::Toolkit::Control *)jarg1;
95882 }
95883
95884 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95885     return (Dali::Toolkit::Control *)jarg1;
95886 }
95887
95888 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95889     return (Dali::Toolkit::Button *)jarg1;
95890 }
95891
95892 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95893     return (Dali::Toolkit::Button *)jarg1;
95894 }
95895
95896 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95897     return (Dali::Toolkit::Button *)jarg1;
95898 }
95899
95900 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95901     return (Dali::Toolkit::Control *)jarg1;
95902 }
95903
95904 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95905     return (Dali::Toolkit::Control *)jarg1;
95906 }
95907
95908 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95909     return (Dali::Toolkit::Control *)jarg1;
95910 }
95911
95912 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95913     return (Dali::Toolkit::Control *)jarg1;
95914 }
95915
95916 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95917     return (Dali::Toolkit::Control *)jarg1;
95918 }
95919
95920 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95921     return (Dali::RefObject *)jarg1;
95922 }
95923
95924 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95925     return (Dali::Toolkit::Scrollable *)jarg1;
95926 }
95927
95928 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95929     return (Dali::BaseHandle *)jarg1;
95930 }
95931
95932 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95933     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95934 }
95935
95936 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95937     return (Dali::RefObject *)jarg1;
95938 }
95939
95940 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95941     return (Dali::Toolkit::Ruler *)jarg1;
95942 }
95943
95944 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95945     return (Dali::Toolkit::Ruler *)jarg1;
95946 }
95947
95948 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95949     return (Dali::Toolkit::Scrollable *)jarg1;
95950 }
95951
95952 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95953     return (Dali::Toolkit::Control *)jarg1;
95954 }
95955
95956
95957 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95958     return (Dali::Toolkit::Control *)jarg1;
95959 }
95960
95961 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95962     return (Dali::BaseHandle *)jarg1;
95963 }
95964
95965 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95966     return (Dali::BaseHandle *)jarg1;
95967 }
95968
95969 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95970     return (Dali::Toolkit::Control *)jarg1;
95971 }
95972
95973 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95974     return (Dali::Toolkit::Control *)jarg1;
95975 }
95976
95977 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95978     return (Dali::Toolkit::Control *)jarg1;
95979 }
95980
95981 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95982     return (Dali::Toolkit::Control *)jarg1;
95983 }
95984
95985 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95986     return (Dali::Toolkit::Control *)jarg1;
95987 }
95988
95989 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95990     return (Dali::Toolkit::Control *)jarg1;
95991 }
95992
95993 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95994     return (Dali::Toolkit::PageTurnView *)jarg1;
95995 }
95996
95997 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95998     return (Dali::Toolkit::PageTurnView *)jarg1;
95999 }
96000
96001 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
96002     return (Dali::Toolkit::Button *)jarg1;
96003 }
96004
96005 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
96006     return (Dali::BaseHandle *)jarg1;
96007 }
96008
96009 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
96010     return (Dali::BaseHandle *)jarg1;
96011 }
96012
96013 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
96014     return (Dali::BaseHandle *)jarg1;
96015 }
96016
96017 /*
96018  * Widget binding
96019  */
96020 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
96021     return (Dali::BaseHandle *)jarg1;
96022 }
96023
96024 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
96025     return (Dali::BaseObject *)jarg1;
96026 }
96027
96028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
96029   void * jresult ;
96030   Dali::Widget result;
96031
96032   {
96033     try {
96034       result = Dali::Widget::New();
96035     } catch (std::out_of_range& e) {
96036       {
96037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96038       };
96039     } catch (std::exception& e) {
96040       {
96041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96042       };
96043     } catch (...) {
96044       {
96045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96046       };
96047     }
96048   }
96049   jresult = new Dali::Widget((const Dali::Widget &)result);
96050   return jresult;
96051 }
96052
96053
96054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
96055   void * jresult ;
96056   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
96057   Dali::Widget result;
96058
96059   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96060
96061   if (!arg1) {
96062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
96063     return 0;
96064   }
96065   {
96066     try {
96067       jresult = new Dali::Widget(arg1);
96068     } catch (std::out_of_range& e) {
96069       {
96070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96071       };
96072     } catch (std::exception& e) {
96073       {
96074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96075       };
96076     } catch (...) {
96077       {
96078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96079       };
96080     }
96081   }
96082   return jresult;
96083 }
96084
96085
96086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
96087   void * jresult ;
96088   Dali::Widget *result = 0 ;
96089
96090   {
96091     try {
96092       result = (Dali::Widget *)new Dali::Widget();
96093     } catch (std::out_of_range& e) {
96094       {
96095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96096       };
96097     } catch (std::exception& e) {
96098       {
96099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96100       };
96101     } catch (...) {
96102       {
96103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96104       };
96105     }
96106   }
96107   jresult = (void *)result;
96108   return jresult;
96109 }
96110
96111
96112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
96113   void * jresult ;
96114   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96115   Dali::Widget *arg2 = 0 ;
96116   Dali::Widget *result = 0 ;
96117
96118   arg1 = (Dali::Widget *)jarg1;
96119   arg2 = (Dali::Widget *)jarg2;
96120   if (!arg2) {
96121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
96122     return 0;
96123   }
96124   {
96125     try {
96126       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
96127     } catch (std::out_of_range& e) {
96128       {
96129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96130       };
96131     } catch (std::exception& e) {
96132       {
96133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96134       };
96135     } catch (...) {
96136       {
96137         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96138       };
96139     }
96140   }
96141   jresult = (void *)result;
96142   return jresult;
96143 }
96144
96145
96146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
96147   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
96148
96149   arg1 = (Dali::Widget *)jarg1;
96150   {
96151     try {
96152       delete arg1;
96153     } catch (std::out_of_range& e) {
96154       {
96155         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96156       };
96157     } catch (std::exception& e) {
96158       {
96159         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96160       };
96161     } catch (...) {
96162       {
96163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96164       };
96165     }
96166   }
96167 }
96168
96169
96170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
96171   void * jresult ;
96172   SwigDirector_WidgetImpl* result;
96173   {
96174     try {
96175       result = new SwigDirector_WidgetImpl();
96176     } catch (std::out_of_range& e) {
96177       {
96178         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96179       };
96180     } catch (std::exception& e) {
96181       {
96182         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96183       };
96184     } catch (...) {
96185       {
96186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96187       };
96188     }
96189   }
96190   jresult = result;
96191   return jresult;
96192 }
96193
96194
96195 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
96196   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96197   std::string *arg2 = 0 ;
96198   Dali::Window arg3 ;
96199   Dali::Window *argp3 ;
96200
96201   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96202   if (!jarg2) {
96203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96204     return ;
96205   }
96206   std::string arg2_str(jarg2);
96207   arg2 = &arg2_str;
96208   argp3 = (Dali::Window *)jarg3;
96209   if (!argp3) {
96210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96211     return ;
96212   }
96213   arg3 = *argp3;
96214   {
96215     try {
96216       (arg1)->OnCreate((std::string const &)*arg2,arg3);
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 (...) {
96226       {
96227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96228       };
96229     }
96230   }
96231 }
96232
96233 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
96234   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96235   std::string *arg2 = 0 ;
96236   Dali::Window arg3 ;
96237   Dali::Window *argp3 ;
96238
96239   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96240   if (!jarg2) {
96241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96242     return ;
96243   }
96244   std::string arg2_str(jarg2);
96245   arg2 = &arg2_str;
96246   argp3 = (Dali::Window *)jarg3;
96247   if (!argp3) {
96248     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96249     return ;
96250   }
96251   arg3 = *argp3;
96252   {
96253     try {
96254       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
96255     } catch (std::out_of_range& e) {
96256       {
96257         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96258       };
96259     } catch (std::exception& e) {
96260       {
96261         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96262       };
96263     } catch (...) {
96264       {
96265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96266       };
96267     }
96268   }
96269 }
96270
96271
96272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
96273   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96274   std::string *arg2 = 0 ;
96275   Dali::Widget::Termination arg3 ;
96276
96277   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96278   if (!jarg2) {
96279     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96280     return ;
96281   }
96282   std::string arg2_str(jarg2);
96283   arg2 = &arg2_str;
96284   arg3 = (Dali::Widget::Termination)jarg3;
96285   {
96286     try {
96287       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
96288     } catch (std::out_of_range& e) {
96289       {
96290         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96291       };
96292     } catch (std::exception& e) {
96293       {
96294         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96295       };
96296     } catch (...) {
96297       {
96298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96299       };
96300     }
96301   }
96302 }
96303
96304 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96305   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96306   std::string *arg2 = 0 ;
96307   Dali::Widget::Termination arg3 ;
96308
96309   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96310   if (!jarg2) {
96311     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96312     return ;
96313   }
96314   std::string arg2_str(jarg2);
96315   arg2 = &arg2_str;
96316   arg3 = (Dali::Widget::Termination)jarg3;
96317   {
96318     try {
96319       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
96320     } catch (std::out_of_range& e) {
96321       {
96322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96323       };
96324     } catch (std::exception& e) {
96325       {
96326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96327       };
96328     } catch (...) {
96329       {
96330         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96331       };
96332     }
96333   }
96334 }
96335
96336
96337 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
96338   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96339
96340   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96341   {
96342     try {
96343       (arg1)->OnPause();
96344     } catch (std::out_of_range& e) {
96345       {
96346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96347       };
96348     } catch (std::exception& e) {
96349       {
96350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96351       };
96352     } catch (...) {
96353       {
96354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96355       };
96356     }
96357   }
96358 }
96359
96360 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
96361   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96362
96363   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96364   {
96365     try {
96366       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
96367     } catch (std::out_of_range& e) {
96368       {
96369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96370       };
96371     } catch (std::exception& e) {
96372       {
96373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96374       };
96375     } catch (...) {
96376       {
96377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96378       };
96379     }
96380   }
96381 }
96382
96383
96384 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
96385   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96386
96387   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96388   {
96389     try {
96390       (arg1)->OnResume();
96391     } catch (std::out_of_range& e) {
96392       {
96393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96394       };
96395     } catch (std::exception& e) {
96396       {
96397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96398       };
96399     } catch (...) {
96400       {
96401         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96402       };
96403     }
96404   }
96405 }
96406
96407
96408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
96409   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96410
96411   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96412   {
96413     try {
96414       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
96415     } catch (std::out_of_range& e) {
96416       {
96417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96418       };
96419     } catch (std::exception& e) {
96420       {
96421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96422       };
96423     } catch (...) {
96424       {
96425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96426       };
96427     }
96428   }
96429 }
96430
96431
96432 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
96433   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96434   Dali::Window arg2 ;
96435   Dali::Window *argp2 ;
96436
96437   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96438   argp2 = (Dali::Window *)jarg2;
96439   if (!argp2) {
96440     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96441     return ;
96442   }
96443   arg2 = *argp2;
96444   {
96445     try {
96446       (arg1)->OnResize(arg2);
96447     } catch (std::out_of_range& e) {
96448       {
96449         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96450       };
96451     } catch (std::exception& e) {
96452       {
96453         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96454       };
96455     } catch (...) {
96456       {
96457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96458       };
96459     }
96460   }
96461 }
96462
96463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
96464   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96465   Dali::Window arg2 ;
96466   Dali::Window *argp2 ;
96467
96468   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96469   argp2 = (Dali::Window *)jarg2;
96470   if (!argp2) {
96471     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
96472     return ;
96473   }
96474   arg2 = *argp2;
96475   {
96476     try {
96477       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
96478     } catch (std::out_of_range& e) {
96479       {
96480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96481       };
96482     } catch (std::exception& e) {
96483       {
96484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96485       };
96486     } catch (...) {
96487       {
96488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96489       };
96490     }
96491   }
96492 }
96493
96494
96495 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
96496   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96497   std::string *arg2 = 0 ;
96498   int arg3 ;
96499
96500   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96501   if (!jarg2) {
96502     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96503     return ;
96504   }
96505   std::string arg2_str(jarg2);
96506   arg2 = &arg2_str;
96507   arg3 = (int)jarg3;
96508   {
96509     try {
96510       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96511     } catch (std::out_of_range& e) {
96512       {
96513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96514       };
96515     } catch (std::exception& e) {
96516       {
96517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96518       };
96519     } catch (...) {
96520       {
96521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96522       };
96523     }
96524   }
96525 }
96526
96527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96528   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96529   std::string *arg2 = 0 ;
96530   int arg3 ;
96531
96532   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96533   if (!jarg2) {
96534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96535     return ;
96536   }
96537   std::string arg2_str(jarg2);
96538   arg2 = &arg2_str;
96539   arg3 = (int)jarg3;
96540   {
96541     try {
96542       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96543     } catch (std::out_of_range& e) {
96544       {
96545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96546       };
96547     } catch (std::exception& e) {
96548       {
96549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96550       };
96551     } catch (...) {
96552       {
96553         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96554       };
96555     }
96556   }
96557 }
96558
96559
96560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96561   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96562   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96563   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96564
96565   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96566   arg2 = (Dali::SlotObserver *)jarg2;
96567   arg3 = (Dali::CallbackBase *)jarg3;
96568   {
96569     try {
96570       (arg1)->SignalConnected(arg2,arg3);
96571     } catch (std::out_of_range& e) {
96572       {
96573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96574       };
96575     } catch (std::exception& e) {
96576       {
96577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96578       };
96579     } catch (...) {
96580       {
96581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96582       };
96583     }
96584   }
96585 }
96586
96587 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96588   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96589   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96590   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96591
96592   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96593   arg2 = (Dali::SlotObserver *)jarg2;
96594   arg3 = (Dali::CallbackBase *)jarg3;
96595   {
96596     try {
96597       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96598     } catch (std::out_of_range& e) {
96599       {
96600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96601       };
96602     } catch (std::exception& e) {
96603       {
96604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96605       };
96606     } catch (...) {
96607       {
96608         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96609       };
96610     }
96611   }
96612 }
96613
96614
96615 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96616   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96617   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96618   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96619
96620   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96621   arg2 = (Dali::SlotObserver *)jarg2;
96622   arg3 = (Dali::CallbackBase *)jarg3;
96623   {
96624     try {
96625       (arg1)->SignalDisconnected(arg2,arg3);
96626     } catch (std::out_of_range& e) {
96627       {
96628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96629       };
96630     } catch (std::exception& e) {
96631       {
96632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96633       };
96634     } catch (...) {
96635       {
96636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96637       };
96638     }
96639   }
96640 }
96641
96642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96643   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96644   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96645   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96646
96647   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96648   arg2 = (Dali::SlotObserver *)jarg2;
96649   arg3 = (Dali::CallbackBase *)jarg3;
96650   {
96651     try {
96652       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
96653     } catch (std::out_of_range& e) {
96654       {
96655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96656       };
96657     } catch (std::exception& e) {
96658       {
96659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96660       };
96661     } catch (...) {
96662       {
96663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96664       };
96665     }
96666   }
96667 }
96668
96669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96670   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96671   std::string *arg2 = 0 ;
96672
96673   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96674   if (!jarg2) {
96675     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96676     return ;
96677   }
96678   std::string arg2_str(jarg2);
96679   arg2 = &arg2_str;
96680   {
96681     try {
96682       (arg1)->SetContentInfo((std::string const &)*arg2);
96683     } catch (std::out_of_range& e) {
96684       {
96685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96686       };
96687     } catch (std::exception& e) {
96688       {
96689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96690       };
96691     } catch (...) {
96692       {
96693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96694       };
96695     }
96696   }
96697 }
96698
96699
96700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96701   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96702   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96703
96704   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96705   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96706   {
96707     try {
96708       (arg1)->SetImpl(arg2);
96709     } catch (std::out_of_range& e) {
96710       {
96711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96712       };
96713     } catch (std::exception& e) {
96714       {
96715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96716       };
96717     } catch (...) {
96718       {
96719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96720       };
96721     }
96722   }
96723 }
96724
96725 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) {
96726
96727   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96728   if (director) {
96729     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96730   }
96731 }
96732
96733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96734   void * jresult ;
96735   Dali::Widget *arg1 = 0 ;
96736   SwigDirector_WidgetImpl *result = 0 ;
96737
96738   arg1 = (Dali::Widget *)jarg1;
96739   if (!arg1) {
96740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96741     return 0;
96742   }
96743   {
96744     try {
96745       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96746     } catch (std::out_of_range& e) {
96747       {
96748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96749       };
96750     } catch (std::exception& e) {
96751       {
96752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96753       };
96754     } catch (...) {
96755       {
96756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96757       };
96758     }
96759   }
96760
96761   jresult = (void *)result;
96762   return jresult;
96763 }
96764
96765
96766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96767   void * jresult ;
96768   int *arg1 = (int *) 0 ;
96769   char ***arg2 ;
96770   std::string *arg3 = 0 ;
96771   Dali::WidgetApplication result;
96772   {
96773     int index = 0;
96774     int length = 0;
96775     char *retPtr;
96776     char *nextPtr;
96777     argWidgetC = jarg1;
96778     argWidgetV = new char*[jarg1 + 1];
96779
96780     retPtr = strtok_r( jarg2, " ", &nextPtr);
96781     if( retPtr )
96782     {
96783       length = strlen(retPtr);
96784     }
96785     argWidgetV[index] = new char[length + 1];
96786     if( retPtr )
96787     {
96788       strncpy(argWidgetV[index], retPtr, length);
96789     }
96790     argWidgetV[index][length] = '\0';
96791     index++;
96792
96793     while (index < jarg1)
96794     {
96795       length = 0;
96796       retPtr = strtok_r(NULL, " ", &nextPtr);
96797       if( retPtr )
96798       {
96799         length = strlen(retPtr);
96800       }
96801       argWidgetV[index] = new char[length + 1];
96802       if( retPtr )
96803       {
96804         strncpy(argWidgetV[index], retPtr, length);
96805       }
96806       argWidgetV[index][length] = '\0';
96807       index++;
96808     }
96809
96810     argWidgetV[jarg1] = NULL;
96811     argWidgetC = jarg1;
96812
96813     arg1 = &argWidgetC;
96814     arg2 = &argWidgetV;
96815   }
96816
96817   if (!jarg3) {
96818     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96819     return 0;
96820   }
96821   std::string arg3_str(jarg3);
96822   arg3 = &arg3_str;
96823   {
96824     try {
96825       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96826     } catch (std::out_of_range& e) {
96827       {
96828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96829       };
96830     } catch (std::exception& e) {
96831       {
96832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96833       };
96834     } catch (...) {
96835       {
96836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96837       };
96838     }
96839   }
96840   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96841
96842   return jresult;
96843 }
96844
96845
96846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96847   void * jresult ;
96848   Dali::WidgetApplication *result = 0 ;
96849
96850   {
96851     try {
96852       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96853     } catch (std::out_of_range& e) {
96854       {
96855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96856       };
96857     } catch (std::exception& e) {
96858       {
96859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96860       };
96861     } catch (...) {
96862       {
96863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96864       };
96865     }
96866   }
96867   jresult = (void *)result;
96868   return jresult;
96869 }
96870
96871
96872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96873   void * jresult ;
96874   Dali::WidgetApplication *arg1 = 0 ;
96875   Dali::WidgetApplication *result = 0 ;
96876
96877   arg1 = (Dali::WidgetApplication *)jarg1;
96878   if (!arg1) {
96879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96880     return 0;
96881   }
96882   {
96883     try {
96884       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96885     } catch (std::out_of_range& e) {
96886       {
96887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96888       };
96889     } catch (std::exception& e) {
96890       {
96891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96892       };
96893     } catch (...) {
96894       {
96895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96896       };
96897     }
96898   }
96899   jresult = (void *)result;
96900   return jresult;
96901 }
96902
96903
96904 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96905   void * jresult ;
96906   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96907   Dali::WidgetApplication *arg2 = 0 ;
96908   Dali::WidgetApplication *result = 0 ;
96909
96910   arg1 = (Dali::WidgetApplication *)jarg1;
96911   arg2 = (Dali::WidgetApplication *)jarg2;
96912   if (!arg2) {
96913     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96914     return 0;
96915   }
96916   {
96917     try {
96918       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96919     } catch (std::out_of_range& e) {
96920       {
96921         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96922       };
96923     } catch (std::exception& e) {
96924       {
96925         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96926       };
96927     } catch (...) {
96928       {
96929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96930       };
96931     }
96932   }
96933   jresult = (void *)result;
96934   return jresult;
96935 }
96936
96937
96938 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96939   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96940
96941   arg1 = (Dali::WidgetApplication *)jarg1;
96942   {
96943     try {
96944       delete arg1;
96945       if( argWidgetV )
96946       {
96947         // free string data
96948         for( int i=0; i < argWidgetC+1; i++)
96949         {
96950           delete [] argWidgetV[i];
96951         }
96952         delete [] argWidgetV;
96953       }
96954     } catch (std::out_of_range& e) {
96955       {
96956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96957       };
96958     } catch (std::exception& e) {
96959       {
96960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96961       };
96962     } catch (...) {
96963       {
96964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96965       };
96966     }
96967   }
96968 }
96969
96970
96971 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96972 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96973
96974 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96975 {
96976   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96977   return *widget;
96978 }
96979
96980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96981   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96982   std::string *arg2 = 0 ;
96983
96984   arg1 = (Dali::WidgetApplication *)jarg1;
96985   if (!jarg2) {
96986     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96987     return ;
96988   }
96989   std::string arg2_str(*jarg2);
96990   arg2 = &arg2_str;
96991
96992   if(!_CSharpCreateWidgetFunction)
96993   {
96994     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96995   }
96996
96997   {
96998     try {
96999       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
97000     } catch (std::out_of_range& e) {
97001       {
97002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97003       };
97004     } catch (std::exception& e) {
97005       {
97006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97007       };
97008     } catch (...) {
97009       {
97010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97011       };
97012     }
97013   }
97014
97015   //Typemap argout in c++ file.
97016   //This will convert c++ string to c# string
97017   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
97018 }
97019
97020
97021 //for PixelBuffer and ImageLoading
97022
97023 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
97024     return (Dali::BaseHandle *)jarg1;
97025 }
97026
97027 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
97028   void * jresult ;
97029   unsigned int arg1 ;
97030   unsigned int arg2 ;
97031   Dali::Pixel::Format arg3 ;
97032   Dali::Devel::PixelBuffer result;
97033
97034   arg1 = (unsigned int)jarg1;
97035   arg2 = (unsigned int)jarg2;
97036   arg3 = (Dali::Pixel::Format)jarg3;
97037   {
97038     try {
97039       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
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 (...) {
97049       {
97050         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97051       };
97052     }
97053   }
97054   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97055   return jresult;
97056 }
97057
97058
97059 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
97060   void * jresult ;
97061   Dali::Devel::PixelBuffer *result = 0 ;
97062
97063   {
97064     try {
97065       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
97066     } catch (std::out_of_range& e) {
97067       {
97068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97069       };
97070     } catch (std::exception& e) {
97071       {
97072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97073       };
97074     } catch (...) {
97075       {
97076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97077       };
97078     }
97079   }
97080   jresult = (void *)result;
97081   return jresult;
97082 }
97083
97084
97085 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
97086   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97087
97088   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97089   {
97090     try {
97091       delete arg1;
97092     } catch (std::out_of_range& e) {
97093       {
97094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97095       };
97096     } catch (std::exception& e) {
97097       {
97098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97099       };
97100     } catch (...) {
97101       {
97102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97103       };
97104     }
97105   }
97106 }
97107
97108
97109 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
97110   void * jresult ;
97111   Dali::Devel::PixelBuffer *arg1 = 0 ;
97112   Dali::Devel::PixelBuffer *result = 0 ;
97113
97114   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97115   if (!arg1) {
97116     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97117     return 0;
97118   }
97119   {
97120     try {
97121       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
97122     } catch (std::out_of_range& e) {
97123       {
97124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97125       };
97126     } catch (std::exception& e) {
97127       {
97128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97129       };
97130     } catch (...) {
97131       {
97132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97133       };
97134     }
97135   }
97136   jresult = (void *)result;
97137   return jresult;
97138 }
97139
97140
97141 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
97142   void * jresult ;
97143   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97144   Dali::Devel::PixelBuffer *arg2 = 0 ;
97145   Dali::Devel::PixelBuffer *result = 0 ;
97146
97147   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97148   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
97149   if (!arg2) {
97150     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
97151     return 0;
97152   }
97153   {
97154     try {
97155       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
97156     } catch (std::out_of_range& e) {
97157       {
97158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97159       };
97160     } catch (std::exception& e) {
97161       {
97162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97163       };
97164     } catch (...) {
97165       {
97166         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97167       };
97168     }
97169   }
97170   jresult = (void *)result;
97171   return jresult;
97172 }
97173
97174
97175 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
97176   void * jresult ;
97177   Dali::Devel::PixelBuffer *arg1 = 0 ;
97178   Dali::PixelData result;
97179
97180   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97181   if (!arg1) {
97182     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
97183     return 0;
97184   }
97185   {
97186     try {
97187       result = Dali::Devel::PixelBuffer::Convert(*arg1);
97188     } catch (std::out_of_range& e) {
97189       {
97190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97191       };
97192     } catch (std::exception& e) {
97193       {
97194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97195       };
97196     } catch (...) {
97197       {
97198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97199       };
97200     }
97201   }
97202   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97203   return jresult;
97204 }
97205
97206
97207 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
97208   void * jresult ;
97209   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97210   Dali::PixelData result;
97211
97212   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97213   {
97214     try {
97215       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
97216     } catch (std::out_of_range& e) {
97217       {
97218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97219       };
97220     } catch (std::exception& e) {
97221       {
97222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97223       };
97224     } catch (...) {
97225       {
97226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97227       };
97228     }
97229   }
97230   jresult = new Dali::PixelData((const Dali::PixelData &)result);
97231   return jresult;
97232 }
97233
97234
97235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
97236   void * jresult ;
97237   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97238   unsigned char *result = 0 ;
97239
97240   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97241   {
97242     try {
97243       result = (unsigned char *)(arg1)->GetBuffer();
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 (...) {
97253       {
97254         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97255       };
97256     }
97257   }
97258   jresult = (void *)result;
97259   return jresult;
97260 }
97261
97262
97263 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
97264   unsigned int jresult ;
97265   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97266   unsigned int result;
97267
97268   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97269   {
97270     try {
97271       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
97272     } catch (std::out_of_range& e) {
97273       {
97274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97275       };
97276     } catch (std::exception& e) {
97277       {
97278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97279       };
97280     } catch (...) {
97281       {
97282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97283       };
97284     }
97285   }
97286   jresult = result;
97287   return jresult;
97288 }
97289
97290
97291 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
97292   unsigned int jresult ;
97293   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97294   unsigned int result;
97295
97296   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97297   {
97298     try {
97299       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
97300     } catch (std::out_of_range& e) {
97301       {
97302         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97303       };
97304     } catch (std::exception& e) {
97305       {
97306         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97307       };
97308     } catch (...) {
97309       {
97310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97311       };
97312     }
97313   }
97314   jresult = result;
97315   return jresult;
97316 }
97317
97318
97319 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
97320   int jresult ;
97321   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97322   Dali::Pixel::Format result;
97323
97324   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97325   {
97326     try {
97327       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
97328     } catch (std::out_of_range& e) {
97329       {
97330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97331       };
97332     } catch (std::exception& e) {
97333       {
97334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97335       };
97336     } catch (...) {
97337       {
97338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97339       };
97340     }
97341   }
97342   jresult = (int)result;
97343   return jresult;
97344 }
97345
97346
97347 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
97348   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97349   Dali::Devel::PixelBuffer arg2 ;
97350   float arg3 ;
97351   bool arg4 ;
97352   Dali::Devel::PixelBuffer *argp2 ;
97353
97354   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97355   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97356   if (!argp2) {
97357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97358     return ;
97359   }
97360   arg2 = *argp2;
97361   arg3 = (float)jarg3;
97362   arg4 = jarg4 ? true : false;
97363   {
97364     try {
97365       (arg1)->ApplyMask(arg2,arg3,arg4);
97366     } catch (std::out_of_range& e) {
97367       {
97368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97369       };
97370     } catch (std::exception& e) {
97371       {
97372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97373       };
97374     } catch (...) {
97375       {
97376         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97377       };
97378     }
97379   }
97380 }
97381
97382
97383 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
97384   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97385   Dali::Devel::PixelBuffer arg2 ;
97386   float arg3 ;
97387   Dali::Devel::PixelBuffer *argp2 ;
97388
97389   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97390   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97391   if (!argp2) {
97392     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97393     return ;
97394   }
97395   arg2 = *argp2;
97396   arg3 = (float)jarg3;
97397   {
97398     try {
97399       (arg1)->ApplyMask(arg2,arg3);
97400     } catch (std::out_of_range& e) {
97401       {
97402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97403       };
97404     } catch (std::exception& e) {
97405       {
97406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97407       };
97408     } catch (...) {
97409       {
97410         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97411       };
97412     }
97413   }
97414 }
97415
97416
97417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
97418   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97419   Dali::Devel::PixelBuffer arg2 ;
97420   Dali::Devel::PixelBuffer *argp2 ;
97421
97422   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97423   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
97424   if (!argp2) {
97425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
97426     return ;
97427   }
97428   arg2 = *argp2;
97429   {
97430     try {
97431       (arg1)->ApplyMask(arg2);
97432     } catch (std::out_of_range& e) {
97433       {
97434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97435       };
97436     } catch (std::exception& e) {
97437       {
97438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97439       };
97440     } catch (...) {
97441       {
97442         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97443       };
97444     }
97445   }
97446 }
97447
97448
97449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
97450   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97451   float arg2 ;
97452
97453   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97454   arg2 = (float)jarg2;
97455   {
97456     try {
97457       (arg1)->ApplyGaussianBlur(arg2);
97458     } catch (std::out_of_range& e) {
97459       {
97460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97461       };
97462     } catch (std::exception& e) {
97463       {
97464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97465       };
97466     } catch (...) {
97467       {
97468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97469       };
97470     }
97471   }
97472 }
97473
97474
97475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
97476   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97477   uint16_t arg2 ;
97478   uint16_t arg3 ;
97479   uint16_t arg4 ;
97480   uint16_t arg5 ;
97481
97482   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97483   arg2 = (uint16_t)jarg2;
97484   arg3 = (uint16_t)jarg3;
97485   arg4 = (uint16_t)jarg4;
97486   arg5 = (uint16_t)jarg5;
97487   {
97488     try {
97489       (arg1)->Crop(arg2,arg3,arg4,arg5);
97490     } catch (std::out_of_range& e) {
97491       {
97492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97493       };
97494     } catch (std::exception& e) {
97495       {
97496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97497       };
97498     } catch (...) {
97499       {
97500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97501       };
97502     }
97503   }
97504 }
97505
97506
97507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97508   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97509   uint16_t arg2 ;
97510   uint16_t arg3 ;
97511
97512   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97513   arg2 = (uint16_t)jarg2;
97514   arg3 = (uint16_t)jarg3;
97515   {
97516     try {
97517       (arg1)->Resize(arg2,arg3);
97518     } catch (std::out_of_range& e) {
97519       {
97520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97521       };
97522     } catch (std::exception& e) {
97523       {
97524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97525       };
97526     } catch (...) {
97527       {
97528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97529       };
97530     }
97531   }
97532 }
97533
97534 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97535   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97536   Dali::Degree * arg2 ;
97537
97538   bool result = false;
97539
97540   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97541   arg2 = (Dali::Degree *)jarg2;
97542   {
97543     try {
97544       result = (arg1)->Rotate(*arg2);
97545     } catch (std::out_of_range& e) {
97546       {
97547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97548       };
97549     } catch (std::exception& e) {
97550       {
97551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97552       };
97553     } catch (...) {
97554       {
97555         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97556       };
97557     }
97558   }
97559   return result;
97560 }
97561
97562
97563 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97564   void * jresult ;
97565   std::string *arg1 = 0 ;
97566   Dali::ImageDimensions arg2 ;
97567   Dali::FittingMode::Type arg3 ;
97568   Dali::SamplingMode::Type arg4 ;
97569   bool arg5 ;
97570   Dali::ImageDimensions *argp2 ;
97571   Dali::Devel::PixelBuffer result;
97572
97573   if (!jarg1) {
97574     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97575     return 0;
97576   }
97577   std::string arg1_str(jarg1);
97578   arg1 = &arg1_str;
97579   argp2 = (Dali::ImageDimensions *)jarg2;
97580   if (!argp2) {
97581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97582     return 0;
97583   }
97584   arg2 = *argp2;
97585   arg3 = (Dali::FittingMode::Type)jarg3;
97586   arg4 = (Dali::SamplingMode::Type)jarg4;
97587   arg5 = jarg5 ? true : false;
97588   {
97589     try {
97590       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97591     } catch (std::out_of_range& e) {
97592       {
97593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97594       };
97595     } catch (std::exception& e) {
97596       {
97597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97598       };
97599     } catch (...) {
97600       {
97601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97602       };
97603     }
97604   }
97605   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97606
97607   return jresult;
97608 }
97609
97610
97611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97612   void * jresult ;
97613   std::string *arg1 = 0 ;
97614   Dali::ImageDimensions arg2 ;
97615   Dali::FittingMode::Type arg3 ;
97616   Dali::SamplingMode::Type arg4 ;
97617   Dali::ImageDimensions *argp2 ;
97618   Dali::Devel::PixelBuffer result;
97619
97620   if (!jarg1) {
97621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97622     return 0;
97623   }
97624   std::string arg1_str(jarg1);
97625   arg1 = &arg1_str;
97626   argp2 = (Dali::ImageDimensions *)jarg2;
97627   if (!argp2) {
97628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97629     return 0;
97630   }
97631   arg2 = *argp2;
97632   arg3 = (Dali::FittingMode::Type)jarg3;
97633   arg4 = (Dali::SamplingMode::Type)jarg4;
97634   {
97635     try {
97636       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97637     } catch (std::out_of_range& e) {
97638       {
97639         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97640       };
97641     } catch (std::exception& e) {
97642       {
97643         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97644       };
97645     } catch (...) {
97646       {
97647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97648       };
97649     }
97650   }
97651   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97652
97653   return jresult;
97654 }
97655
97656
97657 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97658   void * jresult ;
97659   std::string *arg1 = 0 ;
97660   Dali::ImageDimensions arg2 ;
97661   Dali::FittingMode::Type arg3 ;
97662   Dali::ImageDimensions *argp2 ;
97663   Dali::Devel::PixelBuffer result;
97664
97665   if (!jarg1) {
97666     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97667     return 0;
97668   }
97669   std::string arg1_str(jarg1);
97670   arg1 = &arg1_str;
97671   argp2 = (Dali::ImageDimensions *)jarg2;
97672   if (!argp2) {
97673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97674     return 0;
97675   }
97676   arg2 = *argp2;
97677   arg3 = (Dali::FittingMode::Type)jarg3;
97678   {
97679     try {
97680       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97681     } catch (std::out_of_range& e) {
97682       {
97683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97684       };
97685     } catch (std::exception& e) {
97686       {
97687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97688       };
97689     } catch (...) {
97690       {
97691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97692       };
97693     }
97694   }
97695   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97696
97697   return jresult;
97698 }
97699
97700
97701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97702   void * jresult ;
97703   std::string *arg1 = 0 ;
97704   Dali::ImageDimensions arg2 ;
97705   Dali::ImageDimensions *argp2 ;
97706   Dali::Devel::PixelBuffer result;
97707
97708   if (!jarg1) {
97709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97710     return 0;
97711   }
97712   std::string arg1_str(jarg1);
97713   arg1 = &arg1_str;
97714   argp2 = (Dali::ImageDimensions *)jarg2;
97715   if (!argp2) {
97716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97717     return 0;
97718   }
97719   arg2 = *argp2;
97720   {
97721     try {
97722       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97723     } catch (std::out_of_range& e) {
97724       {
97725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97726       };
97727     } catch (std::exception& e) {
97728       {
97729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97730       };
97731     } catch (...) {
97732       {
97733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97734       };
97735     }
97736   }
97737   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97738
97739   return jresult;
97740 }
97741
97742
97743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97744   void * jresult ;
97745   std::string *arg1 = 0 ;
97746   Dali::Devel::PixelBuffer result;
97747
97748   if (!jarg1) {
97749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97750     return 0;
97751   }
97752   std::string arg1_str(jarg1);
97753   arg1 = &arg1_str;
97754   {
97755     try {
97756       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97757     } catch (std::out_of_range& e) {
97758       {
97759         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97760       };
97761     } catch (std::exception& e) {
97762       {
97763         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97764       };
97765     } catch (...) {
97766       {
97767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97768       };
97769     }
97770   }
97771   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97772
97773   return jresult;
97774 }
97775
97776
97777 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97778   void * jresult ;
97779   std::string *arg1 = 0 ;
97780   Dali::ImageDimensions arg2 ;
97781   Dali::FittingMode::Type arg3 ;
97782   Dali::SamplingMode::Type arg4 ;
97783   bool arg5 ;
97784   Dali::ImageDimensions *argp2 ;
97785   Dali::ImageDimensions result;
97786
97787   if (!jarg1) {
97788     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97789     return 0;
97790   }
97791   std::string arg1_str(jarg1);
97792   arg1 = &arg1_str;
97793   argp2 = (Dali::ImageDimensions *)jarg2;
97794   if (!argp2) {
97795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97796     return 0;
97797   }
97798   arg2 = *argp2;
97799   arg3 = (Dali::FittingMode::Type)jarg3;
97800   arg4 = (Dali::SamplingMode::Type)jarg4;
97801   arg5 = jarg5 ? true : false;
97802   {
97803     try {
97804       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97805     } catch (std::out_of_range& e) {
97806       {
97807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97808       };
97809     } catch (std::exception& e) {
97810       {
97811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97812       };
97813     } catch (...) {
97814       {
97815         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97816       };
97817     }
97818   }
97819   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97820
97821   return jresult;
97822 }
97823
97824
97825 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97826   void * jresult ;
97827   std::string *arg1 = 0 ;
97828   Dali::ImageDimensions arg2 ;
97829   Dali::FittingMode::Type arg3 ;
97830   Dali::SamplingMode::Type arg4 ;
97831   Dali::ImageDimensions *argp2 ;
97832   Dali::ImageDimensions result;
97833
97834   if (!jarg1) {
97835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97836     return 0;
97837   }
97838   std::string arg1_str(jarg1);
97839   arg1 = &arg1_str;
97840   argp2 = (Dali::ImageDimensions *)jarg2;
97841   if (!argp2) {
97842     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97843     return 0;
97844   }
97845   arg2 = *argp2;
97846   arg3 = (Dali::FittingMode::Type)jarg3;
97847   arg4 = (Dali::SamplingMode::Type)jarg4;
97848   {
97849     try {
97850       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97851     } catch (std::out_of_range& e) {
97852       {
97853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97854       };
97855     } catch (std::exception& e) {
97856       {
97857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97858       };
97859     } catch (...) {
97860       {
97861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97862       };
97863     }
97864   }
97865   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97866
97867   return jresult;
97868 }
97869
97870
97871 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97872   void * jresult ;
97873   std::string *arg1 = 0 ;
97874   Dali::ImageDimensions arg2 ;
97875   Dali::FittingMode::Type arg3 ;
97876   Dali::ImageDimensions *argp2 ;
97877   Dali::ImageDimensions result;
97878
97879   if (!jarg1) {
97880     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97881     return 0;
97882   }
97883   std::string arg1_str(jarg1);
97884   arg1 = &arg1_str;
97885   argp2 = (Dali::ImageDimensions *)jarg2;
97886   if (!argp2) {
97887     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97888     return 0;
97889   }
97890   arg2 = *argp2;
97891   arg3 = (Dali::FittingMode::Type)jarg3;
97892   {
97893     try {
97894       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97895     } catch (std::out_of_range& e) {
97896       {
97897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97898       };
97899     } catch (std::exception& e) {
97900       {
97901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97902       };
97903     } catch (...) {
97904       {
97905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97906       };
97907     }
97908   }
97909   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97910
97911   return jresult;
97912 }
97913
97914
97915 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97916   void * jresult ;
97917   std::string *arg1 = 0 ;
97918   Dali::ImageDimensions arg2 ;
97919   Dali::ImageDimensions *argp2 ;
97920   Dali::ImageDimensions result;
97921
97922   if (!jarg1) {
97923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97924     return 0;
97925   }
97926   std::string arg1_str(jarg1);
97927   arg1 = &arg1_str;
97928   argp2 = (Dali::ImageDimensions *)jarg2;
97929   if (!argp2) {
97930     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97931     return 0;
97932   }
97933   arg2 = *argp2;
97934   {
97935     try {
97936       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97937     } catch (std::out_of_range& e) {
97938       {
97939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97940       };
97941     } catch (std::exception& e) {
97942       {
97943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97944       };
97945     } catch (...) {
97946       {
97947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97948       };
97949     }
97950   }
97951   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97952
97953   return jresult;
97954 }
97955
97956
97957 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97958   void * jresult ;
97959   std::string *arg1 = 0 ;
97960   Dali::ImageDimensions result;
97961
97962   if (!jarg1) {
97963     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97964     return 0;
97965   }
97966   std::string arg1_str(jarg1);
97967   arg1 = &arg1_str;
97968   {
97969     try {
97970       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97971     } catch (std::out_of_range& e) {
97972       {
97973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97974       };
97975     } catch (std::exception& e) {
97976       {
97977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97978       };
97979     } catch (...) {
97980       {
97981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97982       };
97983     }
97984   }
97985   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97986
97987   return jresult;
97988 }
97989
97990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97991   void * jresult ;
97992   std::string *arg1 = 0 ;
97993   Dali::ImageDimensions result;
97994
97995   if (!jarg1) {
97996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97997     return 0;
97998   }
97999   std::string arg1_str(jarg1);
98000   arg1 = &arg1_str;
98001   {
98002     try {
98003       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
98004     } catch (std::out_of_range& e) {
98005       {
98006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98007       };
98008     } catch (std::exception& e) {
98009       {
98010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98011       };
98012     } catch (...) {
98013       {
98014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98015       };
98016     }
98017   }
98018   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
98019
98020   return jresult;
98021 }
98022
98023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
98024   void * jresult ;
98025   std::string *arg1 = 0 ;
98026   Dali::ImageDimensions arg2 ;
98027   Dali::FittingMode::Type arg3 ;
98028   Dali::SamplingMode::Type arg4 ;
98029   bool arg5 ;
98030   Dali::ImageDimensions *argp2 ;
98031   Dali::Devel::PixelBuffer result;
98032
98033   if (!jarg1) {
98034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98035     return 0;
98036   }
98037   std::string arg1_str(jarg1);
98038   arg1 = &arg1_str;
98039   argp2 = (Dali::ImageDimensions *)jarg2;
98040   if (!argp2) {
98041     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98042     return 0;
98043   }
98044   arg2 = *argp2;
98045   arg3 = (Dali::FittingMode::Type)jarg3;
98046   arg4 = (Dali::SamplingMode::Type)jarg4;
98047   arg5 = jarg5 ? true : false;
98048   {
98049     try {
98050       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
98051     } catch (std::out_of_range& e) {
98052       {
98053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98054       };
98055     } catch (std::exception& e) {
98056       {
98057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98058       };
98059     } catch (...) {
98060       {
98061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98062       };
98063     }
98064   }
98065   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98066
98067   return jresult;
98068 }
98069
98070
98071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
98072   void * jresult ;
98073   std::string *arg1 = 0 ;
98074   Dali::ImageDimensions arg2 ;
98075   Dali::FittingMode::Type arg3 ;
98076   Dali::SamplingMode::Type arg4 ;
98077   Dali::ImageDimensions *argp2 ;
98078   Dali::Devel::PixelBuffer result;
98079
98080   if (!jarg1) {
98081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98082     return 0;
98083   }
98084   std::string arg1_str(jarg1);
98085   arg1 = &arg1_str;
98086   argp2 = (Dali::ImageDimensions *)jarg2;
98087   if (!argp2) {
98088     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98089     return 0;
98090   }
98091   arg2 = *argp2;
98092   arg3 = (Dali::FittingMode::Type)jarg3;
98093   arg4 = (Dali::SamplingMode::Type)jarg4;
98094   {
98095     try {
98096       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
98097     } catch (std::out_of_range& e) {
98098       {
98099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98100       };
98101     } catch (std::exception& e) {
98102       {
98103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98104       };
98105     } catch (...) {
98106       {
98107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98108       };
98109     }
98110   }
98111   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98112
98113   return jresult;
98114 }
98115
98116
98117 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
98118   void * jresult ;
98119   std::string *arg1 = 0 ;
98120   Dali::ImageDimensions arg2 ;
98121   Dali::FittingMode::Type arg3 ;
98122   Dali::ImageDimensions *argp2 ;
98123   Dali::Devel::PixelBuffer result;
98124
98125   if (!jarg1) {
98126     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98127     return 0;
98128   }
98129   std::string arg1_str(jarg1);
98130   arg1 = &arg1_str;
98131   argp2 = (Dali::ImageDimensions *)jarg2;
98132   if (!argp2) {
98133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98134     return 0;
98135   }
98136   arg2 = *argp2;
98137   arg3 = (Dali::FittingMode::Type)jarg3;
98138   {
98139     try {
98140       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
98141     } catch (std::out_of_range& e) {
98142       {
98143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98144       };
98145     } catch (std::exception& e) {
98146       {
98147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98148       };
98149     } catch (...) {
98150       {
98151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98152       };
98153     }
98154   }
98155   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98156
98157   return jresult;
98158 }
98159
98160
98161 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
98162   void * jresult ;
98163   std::string *arg1 = 0 ;
98164   Dali::ImageDimensions arg2 ;
98165   Dali::ImageDimensions *argp2 ;
98166   Dali::Devel::PixelBuffer result;
98167
98168   if (!jarg1) {
98169     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98170     return 0;
98171   }
98172   std::string arg1_str(jarg1);
98173   arg1 = &arg1_str;
98174   argp2 = (Dali::ImageDimensions *)jarg2;
98175   if (!argp2) {
98176     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
98177     return 0;
98178   }
98179   arg2 = *argp2;
98180   {
98181     try {
98182       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
98183     } catch (std::out_of_range& e) {
98184       {
98185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98186       };
98187     } catch (std::exception& e) {
98188       {
98189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98190       };
98191     } catch (...) {
98192       {
98193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98194       };
98195     }
98196   }
98197   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98198
98199   return jresult;
98200 }
98201
98202
98203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
98204   void * jresult ;
98205   std::string *arg1 = 0 ;
98206   Dali::Devel::PixelBuffer result;
98207
98208   if (!jarg1) {
98209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98210     return 0;
98211   }
98212   std::string arg1_str(jarg1);
98213   arg1 = &arg1_str;
98214   {
98215     try {
98216       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
98217     } catch (std::out_of_range& e) {
98218       {
98219         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98220       };
98221     } catch (std::exception& e) {
98222       {
98223         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98224       };
98225     } catch (...) {
98226       {
98227         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98228       };
98229     }
98230   }
98231   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
98232
98233   return jresult;
98234 }
98235
98236
98237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
98238   void * jresult ;
98239   Dali::Toolkit::WebView result;
98240
98241   {
98242     try {
98243       result = Dali::Toolkit::WebView::New();
98244     } catch (std::out_of_range& e) {
98245       {
98246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98247       };
98248     } catch (std::exception& e) {
98249       {
98250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98251       };
98252     } catch (Dali::DaliException e) {
98253       {
98254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98255       };
98256     } catch (...) {
98257       {
98258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98259       };
98260     }
98261   }
98262   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98263   return jresult;
98264 }
98265
98266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
98267   void * jresult ;
98268   Dali::Toolkit::WebView result;
98269
98270   std::string *arg1;
98271   std::string *arg2;
98272
98273   if (!jarg1) {
98274     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
98275     return 0;
98276   }
98277   if (!jarg2) {
98278     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
98279     return 0;
98280   }
98281
98282   std::string jarg1_str = std::string(jarg1);
98283   std::string jarg2_str = std::string(jarg2);
98284
98285   arg1 = &jarg1_str;
98286   arg2 = &jarg2_str;
98287
98288   {
98289     try {
98290       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
98291     } catch (std::out_of_range& e) {
98292       {
98293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98294       };
98295     } catch (std::exception& e) {
98296       {
98297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98298       };
98299     } catch (Dali::DaliException e) {
98300       {
98301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98302       };
98303     } catch (...) {
98304       {
98305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98306       };
98307     }
98308   }
98309   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98310   return jresult;
98311 }
98312
98313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
98314   void * jresult ;
98315   Dali::Toolkit::WebView *arg1 = 0 ;
98316   Dali::Toolkit::WebView *result = 0 ;
98317
98318   arg1 = (Dali::Toolkit::WebView *)jarg1;
98319   if (!arg1) {
98320     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98321     return 0;
98322   }
98323   {
98324     try {
98325       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
98326     } catch (std::out_of_range& e) {
98327       {
98328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98329       };
98330     } catch (std::exception& e) {
98331       {
98332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98333       };
98334     } catch (Dali::DaliException e) {
98335       {
98336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98337       };
98338     } catch (...) {
98339       {
98340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98341       };
98342     }
98343   }
98344   jresult = (void *)result;
98345   return jresult;
98346 }
98347
98348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
98349   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98350   arg1 = (Dali::Toolkit::WebView *)jarg1;
98351   {
98352     try {
98353       delete arg1;
98354     } catch (std::out_of_range& e) {
98355       {
98356         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98357       };
98358     } catch (std::exception& e) {
98359       {
98360         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98361       };
98362     } catch (Dali::DaliException e) {
98363       {
98364         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98365       };
98366     } catch (...) {
98367       {
98368         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98369       };
98370     }
98371   }
98372 }
98373
98374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
98375   void * jresult ;
98376   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98377   Dali::Toolkit::WebView *arg2 = 0 ;
98378   Dali::Toolkit::WebView *result = 0 ;
98379
98380   arg1 = (Dali::Toolkit::WebView *)jarg1;
98381   arg2 = (Dali::Toolkit::WebView *)jarg2;
98382   if (!arg2) {
98383     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
98384     return 0;
98385   }
98386   {
98387     try {
98388       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
98389     } catch (std::out_of_range& e) {
98390       {
98391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98392       };
98393     } catch (std::exception& e) {
98394       {
98395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98396       };
98397     } catch (Dali::DaliException e) {
98398       {
98399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98400       };
98401     } catch (...) {
98402       {
98403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98404       };
98405     }
98406   }
98407   jresult = (void *)result;
98408   return jresult;
98409 }
98410
98411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
98412   void * jresult ;
98413   Dali::BaseHandle arg1 ;
98414   Dali::BaseHandle *argp1 ;
98415   Dali::Toolkit::WebView result;
98416
98417   argp1 = (Dali::BaseHandle *)jarg1;
98418   if (!argp1) {
98419     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
98420     return 0;
98421   }
98422   arg1 = *argp1;
98423   {
98424     try {
98425       result = Dali::Toolkit::WebView::DownCast(arg1);
98426     } catch (std::out_of_range& e) {
98427       {
98428         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98429       };
98430     } catch (std::exception& e) {
98431       {
98432         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98433       };
98434     } catch (Dali::DaliException e) {
98435       {
98436         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98437       };
98438     } catch (...) {
98439       {
98440         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98441       };
98442     }
98443   }
98444   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
98445   return jresult;
98446 }
98447
98448 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
98449   return (int) Dali::Toolkit::WebView::Property::URL;
98450 }
98451
98452 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
98453   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
98454 }
98455
98456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
98457   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
98458 }
98459
98460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
98461   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
98462 }
98463
98464 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
98465   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
98466 }
98467
98468 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
98469   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
98470 }
98471
98472 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
98473   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
98474 }
98475
98476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
98477   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
98478 }
98479
98480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
98481   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98482   std::string *arg2;
98483
98484   arg1 = (Dali::Toolkit::WebView *)jarg1;
98485
98486   if (!jarg2) {
98487     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98488     return;
98489   }
98490
98491   std::string jarg2str = std::string(jarg2);
98492   arg2 = &jarg2str;
98493   {
98494     try {
98495       (arg1)->LoadUrl((std::string const &)*arg2);
98496     } catch (std::out_of_range& e) {
98497       {
98498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98499       };
98500     } catch (std::exception& e) {
98501       {
98502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98503       };
98504     } catch (Dali::DaliException e) {
98505       {
98506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98507       };
98508     } catch (...) {
98509       {
98510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98511       };
98512     }
98513   }
98514 }
98515
98516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98517   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98518   std::string *arg2;
98519
98520   arg1 = (Dali::Toolkit::WebView *)jarg1;
98521   if (!jarg2) {
98522     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98523     return;
98524   }
98525   std::string jarg2str = std::string(jarg2);
98526   arg2 = &jarg2str;
98527   {
98528     try {
98529       (arg1)->LoadHTMLString((std::string const &)*arg2);
98530     } catch (std::out_of_range& e) {
98531       {
98532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98533       };
98534     } catch (std::exception& e) {
98535       {
98536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98537       };
98538     } catch (Dali::DaliException e) {
98539       {
98540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98541       };
98542     } catch (...) {
98543       {
98544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98545       };
98546     }
98547   }
98548 }
98549
98550 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98551   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98552
98553   arg1 = (Dali::Toolkit::WebView *)jarg1;
98554   {
98555     try {
98556       (arg1)->Reload();
98557     } catch (std::out_of_range& e) {
98558       {
98559         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98560       };
98561     } catch (std::exception& e) {
98562       {
98563         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98564       };
98565     } catch (Dali::DaliException e) {
98566       {
98567         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98568       };
98569     } catch (...) {
98570       {
98571         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98572       };
98573     }
98574   }
98575 }
98576
98577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98578   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98579
98580   arg1 = (Dali::Toolkit::WebView *)jarg1;
98581   {
98582     try {
98583       (arg1)->StopLoading();
98584     } catch (std::out_of_range& e) {
98585       {
98586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98587       };
98588     } catch (std::exception& e) {
98589       {
98590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98591       };
98592     } catch (Dali::DaliException e) {
98593       {
98594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98595       };
98596     } catch (...) {
98597       {
98598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98599       };
98600     }
98601   }
98602 }
98603
98604 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98605   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98606
98607   arg1 = (Dali::Toolkit::WebView *)jarg1;
98608   {
98609     try {
98610       (arg1)->Suspend();
98611     } catch (std::out_of_range& e) {
98612       {
98613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98614       };
98615     } catch (std::exception& e) {
98616       {
98617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98618       };
98619     } catch (Dali::DaliException e) {
98620       {
98621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98622       };
98623     } catch (...) {
98624       {
98625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98626       };
98627     }
98628   }
98629 }
98630
98631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98632   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98633
98634   arg1 = (Dali::Toolkit::WebView *)jarg1;
98635   {
98636     try {
98637       (arg1)->Resume();
98638     } catch (std::out_of_range& e) {
98639       {
98640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98641       };
98642     } catch (std::exception& e) {
98643       {
98644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98645       };
98646     } catch (Dali::DaliException e) {
98647       {
98648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98649       };
98650     } catch (...) {
98651       {
98652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98653       };
98654     }
98655   }
98656 }
98657
98658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98659   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98660
98661   arg1 = (Dali::Toolkit::WebView *)jarg1;
98662   {
98663     try {
98664       (arg1)->GoBack();
98665     } catch (std::out_of_range& e) {
98666       {
98667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98668       };
98669     } catch (std::exception& e) {
98670       {
98671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98672       };
98673     } catch (Dali::DaliException e) {
98674       {
98675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98676       };
98677     } catch (...) {
98678       {
98679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98680       };
98681     }
98682   }
98683 }
98684
98685 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98686   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98687
98688   arg1 = (Dali::Toolkit::WebView *)jarg1;
98689   {
98690     try {
98691       (arg1)->GoForward();
98692     } catch (std::out_of_range& e) {
98693       {
98694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98695       };
98696     } catch (std::exception& e) {
98697       {
98698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98699       };
98700     } catch (Dali::DaliException e) {
98701       {
98702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98703       };
98704     } catch (...) {
98705       {
98706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98707       };
98708     }
98709   }
98710 }
98711
98712 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98713   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98714   bool ret;
98715
98716   arg1 = (Dali::Toolkit::WebView *)jarg1;
98717   {
98718     try {
98719       ret = (arg1)->CanGoBack();
98720     } catch (std::out_of_range& e) {
98721       {
98722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98723       };
98724     } catch (std::exception& e) {
98725       {
98726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98727       };
98728     } catch (Dali::DaliException e) {
98729       {
98730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98731       };
98732     } catch (...) {
98733       {
98734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98735       };
98736     }
98737   }
98738   return ret;
98739 }
98740
98741 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98742   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98743   bool ret;
98744
98745   arg1 = (Dali::Toolkit::WebView *)jarg1;
98746   {
98747     try {
98748       ret = (arg1)->CanGoForward();
98749     } catch (std::out_of_range& e) {
98750       {
98751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98752       };
98753     } catch (std::exception& e) {
98754       {
98755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98756       };
98757     } catch (Dali::DaliException e) {
98758       {
98759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98760       };
98761     } catch (...) {
98762       {
98763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98764       };
98765     }
98766   }
98767   return ret;
98768 }
98769
98770 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98771   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98772   std::string *arg2;
98773
98774   arg1 = (Dali::Toolkit::WebView *)jarg1;
98775   if (!jarg2) {
98776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98777     return;
98778   }
98779   std::string jarg2_str = std::string(jarg2);
98780   arg2 = &jarg2_str;
98781
98782   {
98783     try {
98784       if (jarg3) {
98785         void (*handler)(char*) = (void (*)(char*)) jarg3;
98786         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98787           handler(SWIG_csharp_string_callback(result.c_str()));
98788         });
98789       } else {
98790         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98791       }
98792     } catch (std::out_of_range& e) {
98793       {
98794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98795       };
98796     } catch (std::exception& e) {
98797       {
98798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98799       };
98800     } catch (Dali::DaliException e) {
98801       {
98802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98803       };
98804     } catch (...) {
98805       {
98806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98807       };
98808     }
98809   }
98810 }
98811
98812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98813 {
98814   if (!jarg2) {
98815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98816     return;
98817   }
98818
98819   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98820   std::string exposedObjectName = jarg2;
98821   void (*handler)(char*) = (void (*)(char*)) jarg3;
98822
98823   {
98824     try {
98825       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98826         handler(SWIG_csharp_string_callback(message.c_str()));
98827       });
98828     } catch (std::out_of_range& e) {
98829       {
98830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98831       };
98832     } catch (std::exception& e) {
98833       {
98834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98835       };
98836     } catch (Dali::DaliException e) {
98837       {
98838         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98839       };
98840     } catch (...) {
98841       {
98842         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98843       };
98844     }
98845   }
98846 }
98847
98848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98849   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98850
98851   arg1 = (Dali::Toolkit::WebView *)jarg1;
98852   {
98853     try {
98854       (arg1)->ClearHistory();
98855     } catch (std::out_of_range& e) {
98856       {
98857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98858       };
98859     } catch (std::exception& e) {
98860       {
98861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98862       };
98863     } catch (Dali::DaliException e) {
98864       {
98865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98866       };
98867     } catch (...) {
98868       {
98869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98870       };
98871     }
98872   }
98873 }
98874
98875 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98876   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98877
98878   arg1 = (Dali::Toolkit::WebView *)jarg1;
98879   {
98880     try {
98881       (arg1)->ClearCache();
98882     } catch (std::out_of_range& e) {
98883       {
98884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98885       };
98886     } catch (std::exception& e) {
98887       {
98888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98889       };
98890     } catch (Dali::DaliException e) {
98891       {
98892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98893       };
98894     } catch (...) {
98895       {
98896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98897       };
98898     }
98899   }
98900 }
98901
98902 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98903   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98904
98905   arg1 = (Dali::Toolkit::WebView *)jarg1;
98906   {
98907     try {
98908       (arg1)->ClearCookies();
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 (Dali::DaliException e) {
98918       {
98919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98920       };
98921     } catch (...) {
98922       {
98923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98924       };
98925     }
98926   }
98927 }
98928
98929 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98930     return (Dali::Toolkit::Control *)jarg1;
98931 }
98932
98933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98934   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98935   SignalConverter::WebViewPageLoadSignal* result = NULL;
98936   {
98937     try {
98938       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98939     } catch (std::out_of_range& e) {
98940       {
98941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98942       };
98943     } catch (std::exception& e) {
98944       {
98945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98946       };
98947     } catch (Dali::DaliException e) {
98948       {
98949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98950       };
98951     } catch (...) {
98952       {
98953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98954       };
98955     }
98956   }
98957   return (void*) result;
98958 }
98959
98960 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98961   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98962   SignalConverter::WebViewPageLoadSignal* result = NULL;
98963   {
98964     try {
98965       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98966     } catch (std::out_of_range& e) {
98967       {
98968         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98969       };
98970     } catch (std::exception& e) {
98971       {
98972         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98973       };
98974     } catch (Dali::DaliException e) {
98975       {
98976         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98977       };
98978     } catch (...) {
98979       {
98980         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98981       };
98982     }
98983   }
98984   return (void*) result;
98985 }
98986
98987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98988 {
98989   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98990   {
98991     try {
98992       delete object;
98993     } catch (std::out_of_range& e) {
98994       {
98995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98996       };
98997     } catch (std::exception& e) {
98998       {
98999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99000       };
99001     } catch (Dali::DaliException e) {
99002       {
99003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99004       };
99005     } catch (...) {
99006       {
99007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99008       };
99009     }
99010   }
99011 }
99012
99013 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
99014 {
99015   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99016   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
99017   {
99018     try {
99019       proxy->Connect(callback);
99020     } catch (std::out_of_range& e) {
99021       {
99022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99023       };
99024     } catch (std::exception& e) {
99025       {
99026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99027       };
99028     } catch (Dali::DaliException e) {
99029       {
99030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99031       };
99032     } catch (...) {
99033       {
99034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99035       };
99036     }
99037   }
99038 }
99039
99040
99041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
99042   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
99043   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
99044   {
99045     try {
99046       proxy->Disconnect(callback);
99047     } catch (std::out_of_range& e) {
99048       {
99049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99050       };
99051     } catch (std::exception& e) {
99052       {
99053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99054       };
99055     } catch (Dali::DaliException e) {
99056       {
99057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99058       };
99059     } catch (...) {
99060       {
99061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99062       };
99063     }
99064   }
99065 }
99066
99067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
99068   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
99069   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
99070   {
99071     try {
99072       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
99073     } catch (std::out_of_range& e) {
99074       {
99075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99076       };
99077     } catch (std::exception& e) {
99078       {
99079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99080       };
99081     } catch (Dali::DaliException e) {
99082       {
99083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99084       };
99085     } catch (...) {
99086       {
99087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99088       };
99089     }
99090   }
99091   return (void*) result;
99092 }
99093
99094 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
99095 {
99096   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99097   {
99098     try {
99099       delete object;
99100     } catch (std::out_of_range& e) {
99101       {
99102         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99103       };
99104     } catch (std::exception& e) {
99105       {
99106         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99107       };
99108     } catch (Dali::DaliException e) {
99109       {
99110         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99111       };
99112     } catch (...) {
99113       {
99114         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99115       };
99116     }
99117   }
99118 }
99119
99120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
99121 {
99122   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99123   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99124   {
99125     try {
99126       proxy->Connect(callback);
99127     } catch (std::out_of_range& e) {
99128       {
99129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99130       };
99131     } catch (std::exception& e) {
99132       {
99133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99134       };
99135     } catch (Dali::DaliException e) {
99136       {
99137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99138       };
99139     } catch (...) {
99140       {
99141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99142       };
99143     }
99144   }
99145 }
99146
99147
99148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
99149   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
99150   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
99151   {
99152     try {
99153       proxy->Disconnect(callback);
99154     } catch (std::out_of_range& e) {
99155       {
99156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
99157       };
99158     } catch (std::exception& e) {
99159       {
99160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
99161       };
99162     } catch (Dali::DaliException e) {
99163       {
99164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
99165       };
99166     } catch (...) {
99167       {
99168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
99169       };
99170     }
99171   }
99172 }
99173
99174 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
99175   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
99176   char * jresult = SWIG_csharp_string_callback((const char *)result);
99177   return jresult;
99178 }
99179
99180 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
99181   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
99182   return result;
99183 }
99184
99185
99186 struct NativeImageSourcePtrHandle
99187 {
99188   NativeImageSourcePtr Ptr;
99189 };
99190
99191 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
99192 {
99193   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99194   return (NativeImageInterface*)(arg1);
99195 }
99196
99197 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
99198 {
99199   void* jresult;
99200   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
99201   {
99202     try {
99203       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
99204     }
99205     catch (std::out_of_range & e) {
99206       {
99207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99208       };
99209     }
99210     catch (std::exception & e) {
99211       {
99212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99213       };
99214     }
99215     catch (Dali::DaliException e) {
99216       {
99217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99218       };
99219     }
99220     catch (...) {
99221       {
99222         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99223       };
99224     }
99225   }
99226   jresult = (void *)handle;
99227   return jresult;
99228 }
99229
99230 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
99231 {
99232   void* jresult;
99233   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
99234   jresult = (void*)( handle->Ptr.Get() );
99235   return jresult;
99236 }
99237
99238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
99239   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
99240   {
99241     try {
99242       delete arg1;
99243     }
99244     catch (std::out_of_range & e) {
99245       {
99246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
99247       };
99248     }
99249     catch (std::exception & e) {
99250       {
99251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
99252       };
99253     }
99254     catch (Dali::DaliException e) {
99255       {
99256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
99257       };
99258     }
99259     catch (...) {
99260       {
99261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
99262       };
99263     }
99264   }
99265 }
99266
99267 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
99268 {
99269   void* jresult;
99270   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99271   uint16_t* arg2 = (uint16_t*)(jarg2);
99272   uint16_t* arg3 = (uint16_t*)(jarg3);
99273   uint16_t* arg4 = (uint16_t*)(jarg4);
99274   {
99275     try {
99276       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
99277     }
99278     catch (std::out_of_range & e) {
99279       {
99280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99281       };
99282     }
99283     catch (std::exception & e) {
99284       {
99285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99286       };
99287     }
99288     catch (Dali::DaliException e) {
99289       {
99290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99291       };
99292     }
99293     catch (...) {
99294       {
99295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99296       };
99297     }
99298   }
99299   return jresult;
99300 }
99301
99302 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
99303 {
99304   bool jresult;
99305   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
99306
99307   {
99308     try {
99309       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
99310     }
99311     catch (std::out_of_range & e) {
99312       {
99313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
99314       };
99315     }
99316     catch (std::exception & e) {
99317       {
99318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
99319       };
99320     }
99321     catch (Dali::DaliException e) {
99322       {
99323         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
99324       };
99325     }
99326     catch (...) {
99327       {
99328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
99329       };
99330     }
99331   }
99332   return jresult;
99333 }
99334
99335
99336 #ifdef __cplusplus
99337 }
99338 #endif
99339