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_GetCurrent() {
37935   void * jresult ;
37936   Dali::Stage result;
37937
37938   {
37939     try {
37940       result = Dali::Stage::GetCurrent();
37941     } catch (std::out_of_range& e) {
37942       {
37943         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37944       };
37945     } catch (std::exception& e) {
37946       {
37947         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37948       };
37949     } catch (Dali::DaliException e) {
37950       {
37951         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37952       };
37953     } catch (...) {
37954       {
37955         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37956       };
37957     }
37958   }
37959
37960   jresult = new Dali::Stage((const Dali::Stage &)result);
37961   return jresult;
37962 }
37963
37964
37965 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Stage_IsInstalled() {
37966   unsigned int jresult ;
37967   bool result;
37968
37969   {
37970     try {
37971       result = (bool)Dali::Stage::IsInstalled();
37972     } catch (std::out_of_range& e) {
37973       {
37974         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
37975       };
37976     } catch (std::exception& e) {
37977       {
37978         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
37979       };
37980     } catch (Dali::DaliException e) {
37981       {
37982         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
37983       };
37984     } catch (...) {
37985       {
37986         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
37987       };
37988     }
37989   }
37990
37991   jresult = result;
37992   return jresult;
37993 }
37994
37995
37996 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_GetDpi(void * jarg1) {
37997   void * jresult ;
37998   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
37999   Dali::Vector2 result;
38000
38001   arg1 = (Dali::Stage *)jarg1;
38002   {
38003     try {
38004       result = ((Dali::Stage const *)arg1)->GetDpi();
38005     } catch (std::out_of_range& e) {
38006       {
38007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38008       };
38009     } catch (std::exception& e) {
38010       {
38011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38012       };
38013     } catch (Dali::DaliException e) {
38014       {
38015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38016       };
38017     } catch (...) {
38018       {
38019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38020       };
38021     }
38022   }
38023
38024   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
38025   return jresult;
38026 }
38027
38028
38029 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_KeepRendering(void * jarg1, float jarg2) {
38030   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38031   float arg2 ;
38032
38033   arg1 = (Dali::Stage *)jarg1;
38034   arg2 = (float)jarg2;
38035   {
38036     try {
38037       (arg1)->KeepRendering(arg2);
38038     } catch (std::out_of_range& e) {
38039       {
38040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38041       };
38042     } catch (std::exception& e) {
38043       {
38044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38045       };
38046     } catch (Dali::DaliException e) {
38047       {
38048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38049       };
38050     } catch (...) {
38051       {
38052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38053       };
38054     }
38055   }
38056
38057 }
38058
38059
38060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_KeyEventSignal(void * jarg1) {
38061   void * jresult ;
38062   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38063   Dali::Stage::KeyEventSignalType *result = 0 ;
38064
38065   arg1 = (Dali::Stage *)jarg1;
38066   {
38067     try {
38068       result = (Dali::Stage::KeyEventSignalType *) &(arg1)->KeyEventSignal();
38069     } catch (std::out_of_range& e) {
38070       {
38071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38072       };
38073     } catch (std::exception& e) {
38074       {
38075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38076       };
38077     } catch (Dali::DaliException e) {
38078       {
38079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38080       };
38081     } catch (...) {
38082       {
38083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38084       };
38085     }
38086   }
38087
38088   jresult = (void *)result;
38089   return jresult;
38090 }
38091
38092
38093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_EventProcessingFinishedSignal(void * jarg1) {
38094   void * jresult ;
38095   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38096   Dali::Stage::EventProcessingFinishedSignalType *result = 0 ;
38097
38098   arg1 = (Dali::Stage *)jarg1;
38099   {
38100     try {
38101       result = (Dali::Stage::EventProcessingFinishedSignalType *) &(arg1)->EventProcessingFinishedSignal();
38102     } catch (std::out_of_range& e) {
38103       {
38104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38105       };
38106     } catch (std::exception& e) {
38107       {
38108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38109       };
38110     } catch (Dali::DaliException e) {
38111       {
38112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38113       };
38114     } catch (...) {
38115       {
38116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38117       };
38118     }
38119   }
38120
38121   jresult = (void *)result;
38122   return jresult;
38123 }
38124
38125
38126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_TouchSignal(void * jarg1) {
38127   void * jresult ;
38128   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38129   Dali::Stage::TouchSignalType *result = 0 ;
38130
38131   arg1 = (Dali::Stage *)jarg1;
38132   {
38133     try {
38134       result = (Dali::Stage::TouchSignalType *) &(arg1)->TouchSignal();
38135     } catch (std::out_of_range& e) {
38136       {
38137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38138       };
38139     } catch (std::exception& e) {
38140       {
38141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38142       };
38143     } catch (Dali::DaliException e) {
38144       {
38145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38146       };
38147     } catch (...) {
38148       {
38149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38150       };
38151     }
38152   }
38153
38154   jresult = (void *)result;
38155   return jresult;
38156 }
38157
38158
38159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_WheelEventSignal(void * jarg1) {
38160   void * jresult ;
38161   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38162   Dali::Stage::WheelEventSignalType *result = 0 ;
38163
38164   arg1 = (Dali::Stage *)jarg1;
38165   {
38166     try {
38167       result = (Dali::Stage::WheelEventSignalType *) &(arg1)->WheelEventSignal();
38168     } catch (std::out_of_range& e) {
38169       {
38170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38171       };
38172     } catch (std::exception& e) {
38173       {
38174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38175       };
38176     } catch (Dali::DaliException e) {
38177       {
38178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38179       };
38180     } catch (...) {
38181       {
38182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38183       };
38184     }
38185   }
38186
38187   jresult = (void *)result;
38188   return jresult;
38189 }
38190
38191
38192 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextLostSignal(void * jarg1) {
38193   void * jresult ;
38194   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38195   Dali::Stage::ContextStatusSignal *result = 0 ;
38196
38197   arg1 = (Dali::Stage *)jarg1;
38198   {
38199     try {
38200       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextLostSignal();
38201     } catch (std::out_of_range& e) {
38202       {
38203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38204       };
38205     } catch (std::exception& e) {
38206       {
38207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38208       };
38209     } catch (Dali::DaliException e) {
38210       {
38211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38212       };
38213     } catch (...) {
38214       {
38215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38216       };
38217     }
38218   }
38219
38220   jresult = (void *)result;
38221   return jresult;
38222 }
38223
38224
38225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_ContextRegainedSignal(void * jarg1) {
38226   void * jresult ;
38227   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38228   Dali::Stage::ContextStatusSignal *result = 0 ;
38229
38230   arg1 = (Dali::Stage *)jarg1;
38231   {
38232     try {
38233       result = (Dali::Stage::ContextStatusSignal *) &(arg1)->ContextRegainedSignal();
38234     } catch (std::out_of_range& e) {
38235       {
38236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38237       };
38238     } catch (std::exception& e) {
38239       {
38240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38241       };
38242     } catch (Dali::DaliException e) {
38243       {
38244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38245       };
38246     } catch (...) {
38247       {
38248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38249       };
38250     }
38251   }
38252
38253   jresult = (void *)result;
38254   return jresult;
38255 }
38256
38257
38258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Stage_SceneCreatedSignal(void * jarg1) {
38259   void * jresult ;
38260   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38261   Dali::Stage::SceneCreatedSignalType *result = 0 ;
38262
38263   arg1 = (Dali::Stage *)jarg1;
38264   {
38265     try {
38266       result = (Dali::Stage::SceneCreatedSignalType *) &(arg1)->SceneCreatedSignal();
38267     } catch (std::out_of_range& e) {
38268       {
38269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38270       };
38271     } catch (std::exception& e) {
38272       {
38273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38274       };
38275     } catch (Dali::DaliException e) {
38276       {
38277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38278       };
38279     } catch (...) {
38280       {
38281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38282       };
38283     }
38284   }
38285
38286   jresult = (void *)result;
38287   return jresult;
38288 }
38289
38290 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Stage_SetRenderingBehavior(void * jarg1, int jarg2) {
38291   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38292   Dali::DevelStage::Rendering arg2 ;
38293
38294   arg1 = (Dali::Stage *)jarg1;
38295   arg2 = (Dali::DevelStage::Rendering)jarg2;
38296   {
38297     try {
38298       DevelStage::SetRenderingBehavior(*arg1,arg2);
38299     } catch (std::out_of_range& e) {
38300       {
38301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38302       };
38303     } catch (std::exception& e) {
38304       {
38305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38306       };
38307     } catch (Dali::DaliException e) {
38308       {
38309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38310       };
38311     } catch (...) {
38312       {
38313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38314       };
38315     }
38316   }
38317
38318 }
38319
38320 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Stage_GetRenderingBehavior(void * jarg1) {
38321
38322   int jresult ;
38323   int result ;
38324   Dali::Stage *arg1 = (Dali::Stage *) 0 ;
38325
38326   arg1 = (Dali::Stage *)jarg1;
38327   {
38328     try {
38329       result = (int)(DevelStage::GetRenderingBehavior(*arg1));
38330     } catch (std::out_of_range& e) {
38331       {
38332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38333       };
38334     } catch (std::exception& e) {
38335       {
38336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38337       };
38338     } catch (Dali::DaliException e) {
38339       {
38340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38341       };
38342     } catch (...) {
38343       {
38344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38345       };
38346     }
38347   }
38348
38349   jresult = result;
38350   return jresult;
38351 }
38352
38353 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RelayoutContainer(void * jarg1) {
38354   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38355
38356   arg1 = (Dali::RelayoutContainer *)jarg1;
38357   {
38358     try {
38359       delete arg1;
38360     } catch (std::out_of_range& e) {
38361       {
38362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38363       };
38364     } catch (std::exception& e) {
38365       {
38366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38367       };
38368     } catch (Dali::DaliException e) {
38369       {
38370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38371       };
38372     } catch (...) {
38373       {
38374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38375       };
38376     }
38377   }
38378
38379 }
38380
38381
38382 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RelayoutContainer_Add(void * jarg1, void * jarg2, void * jarg3) {
38383   Dali::RelayoutContainer *arg1 = (Dali::RelayoutContainer *) 0 ;
38384   Dali::Actor *arg2 = 0 ;
38385   Dali::Vector2 *arg3 = 0 ;
38386
38387   arg1 = (Dali::RelayoutContainer *)jarg1;
38388   arg2 = (Dali::Actor *)jarg2;
38389   if (!arg2) {
38390     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38391     return ;
38392   }
38393   arg3 = (Dali::Vector2 *)jarg3;
38394   if (!arg3) {
38395     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38396     return ;
38397   }
38398   {
38399     try {
38400       (arg1)->Add((Dali::Actor const &)*arg2,(Dali::Vector2 const &)*arg3);
38401     } catch (std::out_of_range& e) {
38402       {
38403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38404       };
38405     } catch (std::exception& e) {
38406       {
38407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38408       };
38409     } catch (Dali::DaliException e) {
38410       {
38411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38412       };
38413     } catch (...) {
38414       {
38415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38416       };
38417     }
38418   }
38419
38420 }
38421
38422
38423 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_Self(void * jarg1) {
38424   void * jresult ;
38425   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38426   Dali::CustomActor result;
38427
38428   arg1 = (Dali::CustomActorImpl *)jarg1;
38429   {
38430     try {
38431       result = ((Dali::CustomActorImpl const *)arg1)->Self();
38432     } catch (std::out_of_range& e) {
38433       {
38434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38435       };
38436     } catch (std::exception& e) {
38437       {
38438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38439       };
38440     } catch (Dali::DaliException e) {
38441       {
38442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38443       };
38444     } catch (...) {
38445       {
38446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38447       };
38448     }
38449   }
38450
38451   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
38452   return jresult;
38453 }
38454
38455
38456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageConnection(void * jarg1, int jarg2) {
38457   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38458   int arg2 ;
38459
38460   arg1 = (Dali::CustomActorImpl *)jarg1;
38461   arg2 = (int)jarg2;
38462   {
38463     try {
38464       (arg1)->OnStageConnection(arg2);
38465     } catch (std::out_of_range& e) {
38466       {
38467         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38468       };
38469     } catch (std::exception& e) {
38470       {
38471         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38472       };
38473     } catch (Dali::DaliException e) {
38474       {
38475         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38476       };
38477     } catch (...) {
38478       {
38479         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38480       };
38481     }
38482   }
38483
38484 }
38485
38486
38487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnStageDisconnection(void * jarg1) {
38488   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38489
38490   arg1 = (Dali::CustomActorImpl *)jarg1;
38491   {
38492     try {
38493       (arg1)->OnStageDisconnection();
38494     } catch (std::out_of_range& e) {
38495       {
38496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38497       };
38498     } catch (std::exception& e) {
38499       {
38500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38501       };
38502     } catch (Dali::DaliException e) {
38503       {
38504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38505       };
38506     } catch (...) {
38507       {
38508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38509       };
38510     }
38511   }
38512
38513 }
38514
38515
38516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildAdd(void * jarg1, void * jarg2) {
38517   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38518   Dali::Actor *arg2 = 0 ;
38519
38520   arg1 = (Dali::CustomActorImpl *)jarg1;
38521   arg2 = (Dali::Actor *)jarg2;
38522   if (!arg2) {
38523     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38524     return ;
38525   }
38526   {
38527     try {
38528       (arg1)->OnChildAdd(*arg2);
38529     } catch (std::out_of_range& e) {
38530       {
38531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38532       };
38533     } catch (std::exception& e) {
38534       {
38535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38536       };
38537     } catch (Dali::DaliException e) {
38538       {
38539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38540       };
38541     } catch (...) {
38542       {
38543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38544       };
38545     }
38546   }
38547
38548 }
38549
38550
38551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnChildRemove(void * jarg1, void * jarg2) {
38552   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38553   Dali::Actor *arg2 = 0 ;
38554
38555   arg1 = (Dali::CustomActorImpl *)jarg1;
38556   arg2 = (Dali::Actor *)jarg2;
38557   if (!arg2) {
38558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
38559     return ;
38560   }
38561   {
38562     try {
38563       (arg1)->OnChildRemove(*arg2);
38564     } catch (std::out_of_range& e) {
38565       {
38566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38567       };
38568     } catch (std::exception& e) {
38569       {
38570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38571       };
38572     } catch (Dali::DaliException e) {
38573       {
38574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38575       };
38576     } catch (...) {
38577       {
38578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38579       };
38580     }
38581   }
38582
38583 }
38584
38585
38586 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
38587   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38588   Dali::Property::Index arg2 ;
38589   Dali::Property::Value arg3 ;
38590   Dali::Property::Value *argp3 ;
38591
38592   arg1 = (Dali::CustomActorImpl *)jarg1;
38593   arg2 = (Dali::Property::Index)jarg2;
38594   argp3 = (Dali::Property::Value *)jarg3;
38595   if (!argp3) {
38596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
38597     return ;
38598   }
38599   arg3 = *argp3;
38600   {
38601     try {
38602       (arg1)->OnPropertySet(arg2,arg3);
38603     } catch (std::out_of_range& e) {
38604       {
38605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38606       };
38607     } catch (std::exception& e) {
38608       {
38609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38610       };
38611     } catch (Dali::DaliException e) {
38612       {
38613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38614       };
38615     } catch (...) {
38616       {
38617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38618       };
38619     }
38620   }
38621
38622 }
38623
38624
38625 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeSet(void * jarg1, void * jarg2) {
38626   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38627   Dali::Vector3 *arg2 = 0 ;
38628
38629   arg1 = (Dali::CustomActorImpl *)jarg1;
38630   arg2 = (Dali::Vector3 *)jarg2;
38631   if (!arg2) {
38632     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38633     return ;
38634   }
38635   {
38636     try {
38637       (arg1)->OnSizeSet((Dali::Vector3 const &)*arg2);
38638     } catch (std::out_of_range& e) {
38639       {
38640         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38641       };
38642     } catch (std::exception& e) {
38643       {
38644         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38645       };
38646     } catch (Dali::DaliException e) {
38647       {
38648         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38649       };
38650     } catch (...) {
38651       {
38652         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38653       };
38654     }
38655   }
38656
38657 }
38658
38659 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
38660   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38661   Dali::Animation *arg2 = 0 ;
38662   Dali::Vector3 *arg3 = 0 ;
38663
38664   arg1 = (Dali::CustomActorImpl *)jarg1;
38665   arg2 = (Dali::Animation *)jarg2;
38666   if (!arg2) {
38667     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
38668     return ;
38669   }
38670   arg3 = (Dali::Vector3 *)jarg3;
38671   if (!arg3) {
38672     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
38673     return ;
38674   }
38675   {
38676     try {
38677       (arg1)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
38678     } catch (std::out_of_range& e) {
38679       {
38680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38681       };
38682     } catch (std::exception& e) {
38683       {
38684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38685       };
38686     } catch (Dali::DaliException e) {
38687       {
38688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38689       };
38690     } catch (...) {
38691       {
38692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38693       };
38694     }
38695   }
38696
38697 }
38698
38699
38700 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnTouchEvent(void * jarg1, void * jarg2) {
38701   unsigned int jresult ;
38702   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38703   Dali::TouchEvent *arg2 = 0 ;
38704   bool result;
38705
38706   arg1 = (Dali::CustomActorImpl *)jarg1;
38707   arg2 = (Dali::TouchEvent *)jarg2;
38708   if (!arg2) {
38709     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
38710     return 0;
38711   }
38712   {
38713     try {
38714       result = (bool)(arg1)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
38715     } catch (std::out_of_range& e) {
38716       {
38717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38718       };
38719     } catch (std::exception& e) {
38720       {
38721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38722       };
38723     } catch (Dali::DaliException e) {
38724       {
38725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38726       };
38727     } catch (...) {
38728       {
38729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38730       };
38731     }
38732   }
38733
38734   jresult = result;
38735   return jresult;
38736 }
38737
38738
38739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnHoverEvent(void * jarg1, void * jarg2) {
38740   unsigned int jresult ;
38741   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38742   Dali::HoverEvent *arg2 = 0 ;
38743   bool result;
38744
38745   arg1 = (Dali::CustomActorImpl *)jarg1;
38746   arg2 = (Dali::HoverEvent *)jarg2;
38747   if (!arg2) {
38748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
38749     return 0;
38750   }
38751   {
38752     try {
38753       result = (bool)(arg1)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
38754     } catch (std::out_of_range& e) {
38755       {
38756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38757       };
38758     } catch (std::exception& e) {
38759       {
38760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38761       };
38762     } catch (Dali::DaliException e) {
38763       {
38764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38765       };
38766     } catch (...) {
38767       {
38768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38769       };
38770     }
38771   }
38772
38773   jresult = result;
38774   return jresult;
38775 }
38776
38777
38778 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnKeyEvent(void * jarg1, void * jarg2) {
38779   unsigned int jresult ;
38780   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38781   Dali::KeyEvent *arg2 = 0 ;
38782   bool result;
38783
38784   arg1 = (Dali::CustomActorImpl *)jarg1;
38785   arg2 = (Dali::KeyEvent *)jarg2;
38786   if (!arg2) {
38787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
38788     return 0;
38789   }
38790   {
38791     try {
38792       result = (bool)(arg1)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
38793     } catch (std::out_of_range& e) {
38794       {
38795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38796       };
38797     } catch (std::exception& e) {
38798       {
38799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38800       };
38801     } catch (Dali::DaliException e) {
38802       {
38803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38804       };
38805     } catch (...) {
38806       {
38807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38808       };
38809     }
38810   }
38811
38812   jresult = result;
38813   return jresult;
38814 }
38815
38816
38817 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnWheelEvent(void * jarg1, void * jarg2) {
38818   unsigned int jresult ;
38819   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38820   Dali::WheelEvent *arg2 = 0 ;
38821   bool result;
38822
38823   arg1 = (Dali::CustomActorImpl *)jarg1;
38824   arg2 = (Dali::WheelEvent *)jarg2;
38825   if (!arg2) {
38826     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
38827     return 0;
38828   }
38829   {
38830     try {
38831       result = (bool)(arg1)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
38832     } catch (std::out_of_range& e) {
38833       {
38834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38835       };
38836     } catch (std::exception& e) {
38837       {
38838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38839       };
38840     } catch (Dali::DaliException e) {
38841       {
38842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38843       };
38844     } catch (...) {
38845       {
38846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38847       };
38848     }
38849   }
38850
38851   jresult = result;
38852   return jresult;
38853 }
38854
38855
38856 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
38857   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38858   Dali::Vector2 *arg2 = 0 ;
38859   Dali::RelayoutContainer *arg3 = 0 ;
38860
38861   arg1 = (Dali::CustomActorImpl *)jarg1;
38862   arg2 = (Dali::Vector2 *)jarg2;
38863   if (!arg2) {
38864     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
38865     return ;
38866   }
38867   arg3 = (Dali::RelayoutContainer *)jarg3;
38868   if (!arg3) {
38869     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
38870     return ;
38871   }
38872   {
38873     try {
38874       (arg1)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
38875     } catch (std::out_of_range& e) {
38876       {
38877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38878       };
38879     } catch (std::exception& e) {
38880       {
38881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38882       };
38883     } catch (Dali::DaliException e) {
38884       {
38885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38886       };
38887     } catch (...) {
38888       {
38889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38890       };
38891     }
38892   }
38893
38894 }
38895
38896
38897 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
38898   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38899   Dali::ResizePolicy::Type arg2 ;
38900   Dali::Dimension::Type arg3 ;
38901
38902   arg1 = (Dali::CustomActorImpl *)jarg1;
38903   arg2 = (Dali::ResizePolicy::Type)jarg2;
38904   arg3 = (Dali::Dimension::Type)jarg3;
38905   {
38906     try {
38907       (arg1)->OnSetResizePolicy(arg2,arg3);
38908     } catch (std::out_of_range& e) {
38909       {
38910         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
38911       };
38912     } catch (std::exception& e) {
38913       {
38914         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
38915       };
38916     } catch (Dali::DaliException e) {
38917       {
38918         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
38919       };
38920     } catch (...) {
38921       {
38922         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
38923       };
38924     }
38925   }
38926
38927 }
38928
38929
38930 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetNaturalSize(void * jarg1) {
38931   void * jresult ;
38932   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38933   Dali::Vector3 result;
38934
38935   arg1 = (Dali::CustomActorImpl *)jarg1;
38936   {
38937     try {
38938       result = (arg1)->GetNaturalSize();
38939     } catch (std::out_of_range& e) {
38940       {
38941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38942       };
38943     } catch (std::exception& e) {
38944       {
38945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38946       };
38947     } catch (Dali::DaliException e) {
38948       {
38949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38950       };
38951     } catch (...) {
38952       {
38953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38954       };
38955     }
38956   }
38957
38958   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
38959   return jresult;
38960 }
38961
38962
38963 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
38964   float jresult ;
38965   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
38966   Dali::Actor *arg2 = 0 ;
38967   Dali::Dimension::Type arg3 ;
38968   float result;
38969
38970   arg1 = (Dali::CustomActorImpl *)jarg1;
38971   arg2 = (Dali::Actor *)jarg2;
38972   if (!arg2) {
38973     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
38974     return 0;
38975   }
38976   arg3 = (Dali::Dimension::Type)jarg3;
38977   {
38978     try {
38979       result = (float)(arg1)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
38980     } catch (std::out_of_range& e) {
38981       {
38982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
38983       };
38984     } catch (std::exception& e) {
38985       {
38986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
38987       };
38988     } catch (Dali::DaliException e) {
38989       {
38990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
38991       };
38992     } catch (...) {
38993       {
38994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
38995       };
38996     }
38997   }
38998
38999   jresult = result;
39000   return jresult;
39001 }
39002
39003
39004 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetHeightForWidth(void * jarg1, float jarg2) {
39005   float jresult ;
39006   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39007   float arg2 ;
39008   float result;
39009
39010   arg1 = (Dali::CustomActorImpl *)jarg1;
39011   arg2 = (float)jarg2;
39012   {
39013     try {
39014       result = (float)(arg1)->GetHeightForWidth(arg2);
39015     } catch (std::out_of_range& e) {
39016       {
39017         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39018       };
39019     } catch (std::exception& e) {
39020       {
39021         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39022       };
39023     } catch (Dali::DaliException e) {
39024       {
39025         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39026       };
39027     } catch (...) {
39028       {
39029         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39030       };
39031     }
39032   }
39033
39034   jresult = result;
39035   return jresult;
39036 }
39037
39038
39039 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CustomActorImpl_GetWidthForHeight(void * jarg1, float jarg2) {
39040   float jresult ;
39041   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39042   float arg2 ;
39043   float result;
39044
39045   arg1 = (Dali::CustomActorImpl *)jarg1;
39046   arg2 = (float)jarg2;
39047   {
39048     try {
39049       result = (float)(arg1)->GetWidthForHeight(arg2);
39050     } catch (std::out_of_range& e) {
39051       {
39052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39053       };
39054     } catch (std::exception& e) {
39055       {
39056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39057       };
39058     } catch (Dali::DaliException e) {
39059       {
39060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39061       };
39062     } catch (...) {
39063       {
39064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39065       };
39066     }
39067   }
39068
39069   jresult = result;
39070   return jresult;
39071 }
39072
39073
39074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
39075   unsigned int jresult ;
39076   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39077   Dali::Dimension::Type arg2 ;
39078   bool result;
39079
39080   arg1 = (Dali::CustomActorImpl *)jarg1;
39081   arg2 = (Dali::Dimension::Type)jarg2;
39082   {
39083     try {
39084       result = (bool)(arg1)->RelayoutDependentOnChildren(arg2);
39085     } catch (std::out_of_range& e) {
39086       {
39087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39088       };
39089     } catch (std::exception& e) {
39090       {
39091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39092       };
39093     } catch (Dali::DaliException e) {
39094       {
39095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39096       };
39097     } catch (...) {
39098       {
39099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39100       };
39101     }
39102   }
39103
39104   jresult = result;
39105   return jresult;
39106 }
39107
39108
39109 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
39110   unsigned int jresult ;
39111   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39112   bool result;
39113
39114   arg1 = (Dali::CustomActorImpl *)jarg1;
39115   {
39116     try {
39117       result = (bool)(arg1)->RelayoutDependentOnChildren();
39118     } catch (std::out_of_range& e) {
39119       {
39120         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39121       };
39122     } catch (std::exception& e) {
39123       {
39124         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39125       };
39126     } catch (Dali::DaliException e) {
39127       {
39128         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39129       };
39130     } catch (...) {
39131       {
39132         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39133       };
39134     }
39135   }
39136
39137   jresult = result;
39138   return jresult;
39139 }
39140
39141
39142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
39143   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39144   Dali::Dimension::Type arg2 ;
39145
39146   arg1 = (Dali::CustomActorImpl *)jarg1;
39147   arg2 = (Dali::Dimension::Type)jarg2;
39148   {
39149     try {
39150       (arg1)->OnCalculateRelayoutSize(arg2);
39151     } catch (std::out_of_range& e) {
39152       {
39153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39154       };
39155     } catch (std::exception& e) {
39156       {
39157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39158       };
39159     } catch (Dali::DaliException e) {
39160       {
39161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39162       };
39163     } catch (...) {
39164       {
39165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39166       };
39167     }
39168   }
39169
39170 }
39171
39172
39173 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomActorImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
39174   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39175   float arg2 ;
39176   Dali::Dimension::Type arg3 ;
39177
39178   arg1 = (Dali::CustomActorImpl *)jarg1;
39179   arg2 = (float)jarg2;
39180   arg3 = (Dali::Dimension::Type)jarg3;
39181   {
39182     try {
39183       (arg1)->OnLayoutNegotiated(arg2,arg3);
39184     } catch (std::out_of_range& e) {
39185       {
39186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39187       };
39188     } catch (std::exception& e) {
39189       {
39190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39191       };
39192     } catch (Dali::DaliException e) {
39193       {
39194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39195       };
39196     } catch (...) {
39197       {
39198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39199       };
39200     }
39201   }
39202
39203 }
39204
39205
39206 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresTouchEvents(void * jarg1) {
39207   unsigned int jresult ;
39208   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39209   bool result;
39210
39211   arg1 = (Dali::CustomActorImpl *)jarg1;
39212   {
39213     try {
39214       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresTouchEvents();
39215     } catch (std::out_of_range& e) {
39216       {
39217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39218       };
39219     } catch (std::exception& e) {
39220       {
39221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39222       };
39223     } catch (Dali::DaliException e) {
39224       {
39225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39226       };
39227     } catch (...) {
39228       {
39229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39230       };
39231     }
39232   }
39233
39234   jresult = result;
39235   return jresult;
39236 }
39237
39238
39239 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresHoverEvents(void * jarg1) {
39240   unsigned int jresult ;
39241   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39242   bool result;
39243
39244   arg1 = (Dali::CustomActorImpl *)jarg1;
39245   {
39246     try {
39247       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresHoverEvents();
39248     } catch (std::out_of_range& e) {
39249       {
39250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39251       };
39252     } catch (std::exception& e) {
39253       {
39254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39255       };
39256     } catch (Dali::DaliException e) {
39257       {
39258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39259       };
39260     } catch (...) {
39261       {
39262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39263       };
39264     }
39265   }
39266
39267   jresult = result;
39268   return jresult;
39269 }
39270
39271
39272 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_RequiresWheelEvents(void * jarg1) {
39273   unsigned int jresult ;
39274   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39275   bool result;
39276
39277   arg1 = (Dali::CustomActorImpl *)jarg1;
39278   {
39279     try {
39280       result = (bool)((Dali::CustomActorImpl const *)arg1)->RequiresWheelEvents();
39281     } catch (std::out_of_range& e) {
39282       {
39283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39284       };
39285     } catch (std::exception& e) {
39286       {
39287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39288       };
39289     } catch (Dali::DaliException e) {
39290       {
39291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39292       };
39293     } catch (...) {
39294       {
39295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39296       };
39297     }
39298   }
39299
39300   jresult = result;
39301   return jresult;
39302 }
39303
39304
39305 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CustomActorImpl_IsRelayoutEnabled(void * jarg1) {
39306   unsigned int jresult ;
39307   Dali::CustomActorImpl *arg1 = (Dali::CustomActorImpl *) 0 ;
39308   bool result;
39309
39310   arg1 = (Dali::CustomActorImpl *)jarg1;
39311   {
39312     try {
39313       result = (bool)((Dali::CustomActorImpl const *)arg1)->IsRelayoutEnabled();
39314     } catch (std::out_of_range& e) {
39315       {
39316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39317       };
39318     } catch (std::exception& e) {
39319       {
39320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39321       };
39322     } catch (Dali::DaliException e) {
39323       {
39324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39325       };
39326     } catch (...) {
39327       {
39328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39329       };
39330     }
39331   }
39332
39333   jresult = result;
39334   return jresult;
39335 }
39336
39337
39338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_0() {
39339   void * jresult ;
39340   Dali::CustomActor *result = 0 ;
39341
39342   {
39343     try {
39344       result = (Dali::CustomActor *)new Dali::CustomActor();
39345     } catch (std::out_of_range& e) {
39346       {
39347         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39348       };
39349     } catch (std::exception& e) {
39350       {
39351         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39352       };
39353     } catch (Dali::DaliException e) {
39354       {
39355         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39356       };
39357     } catch (...) {
39358       {
39359         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39360       };
39361     }
39362   }
39363
39364   jresult = (void *)result;
39365   return jresult;
39366 }
39367
39368
39369 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_DownCast(void * jarg1) {
39370   void * jresult ;
39371   Dali::BaseHandle arg1 ;
39372   Dali::BaseHandle *argp1 ;
39373   Dali::CustomActor result;
39374
39375   argp1 = (Dali::BaseHandle *)jarg1;
39376   if (!argp1) {
39377     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39378     return 0;
39379   }
39380   arg1 = *argp1;
39381   {
39382     try {
39383       result = Dali::CustomActor::DownCast(arg1);
39384     } catch (std::out_of_range& e) {
39385       {
39386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39387       };
39388     } catch (std::exception& e) {
39389       {
39390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39391       };
39392     } catch (Dali::DaliException e) {
39393       {
39394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39395       };
39396     } catch (...) {
39397       {
39398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39399       };
39400     }
39401   }
39402
39403   jresult = new Dali::CustomActor((const Dali::CustomActor &)result);
39404   return jresult;
39405 }
39406
39407
39408 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomActor(void * jarg1) {
39409   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39410
39411   arg1 = (Dali::CustomActor *)jarg1;
39412   {
39413     try {
39414       delete arg1;
39415     } catch (std::out_of_range& e) {
39416       {
39417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39418       };
39419     } catch (std::exception& e) {
39420       {
39421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39422       };
39423     } catch (Dali::DaliException e) {
39424       {
39425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39426       };
39427     } catch (...) {
39428       {
39429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39430       };
39431     }
39432   }
39433
39434 }
39435
39436
39437 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_GetImplementation(void * jarg1) {
39438   void * jresult ;
39439   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39440   Dali::CustomActorImpl *result = 0 ;
39441
39442   arg1 = (Dali::CustomActor *)jarg1;
39443   {
39444     try {
39445       result = (Dali::CustomActorImpl *) &((Dali::CustomActor const *)arg1)->GetImplementation();
39446     } catch (std::out_of_range& e) {
39447       {
39448         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39449       };
39450     } catch (std::exception& e) {
39451       {
39452         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39453       };
39454     } catch (Dali::DaliException e) {
39455       {
39456         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39457       };
39458     } catch (...) {
39459       {
39460         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39461       };
39462     }
39463   }
39464
39465   jresult = (void *)result;
39466   return jresult;
39467 }
39468
39469
39470 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_1(void * jarg1) {
39471   void * jresult ;
39472   Dali::CustomActorImpl *arg1 = 0 ;
39473   Dali::CustomActor *result = 0 ;
39474
39475   arg1 = (Dali::CustomActorImpl *)jarg1;
39476   if (!arg1) {
39477     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActorImpl & type is null", 0);
39478     return 0;
39479   }
39480   {
39481     try {
39482       result = (Dali::CustomActor *)new Dali::CustomActor(*arg1);
39483     } catch (std::out_of_range& e) {
39484       {
39485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39486       };
39487     } catch (std::exception& e) {
39488       {
39489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39490       };
39491     } catch (Dali::DaliException e) {
39492       {
39493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39494       };
39495     } catch (...) {
39496       {
39497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39498       };
39499     }
39500   }
39501
39502   jresult = (void *)result;
39503   return jresult;
39504 }
39505
39506
39507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomActor__SWIG_2(void * jarg1) {
39508   void * jresult ;
39509   Dali::CustomActor *arg1 = 0 ;
39510   Dali::CustomActor *result = 0 ;
39511
39512   arg1 = (Dali::CustomActor *)jarg1;
39513   if (!arg1) {
39514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39515     return 0;
39516   }
39517   {
39518     try {
39519       result = (Dali::CustomActor *)new Dali::CustomActor((Dali::CustomActor const &)*arg1);
39520     } catch (std::out_of_range& e) {
39521       {
39522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39523       };
39524     } catch (std::exception& e) {
39525       {
39526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39527       };
39528     } catch (Dali::DaliException e) {
39529       {
39530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39531       };
39532     } catch (...) {
39533       {
39534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39535       };
39536     }
39537   }
39538
39539   jresult = (void *)result;
39540   return jresult;
39541 }
39542
39543
39544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomActor_Assign(void * jarg1, void * jarg2) {
39545   void * jresult ;
39546   Dali::CustomActor *arg1 = (Dali::CustomActor *) 0 ;
39547   Dali::CustomActor *arg2 = 0 ;
39548   Dali::CustomActor *result = 0 ;
39549
39550   arg1 = (Dali::CustomActor *)jarg1;
39551   arg2 = (Dali::CustomActor *)jarg2;
39552   if (!arg2) {
39553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CustomActor const & type is null", 0);
39554     return 0;
39555   }
39556   {
39557     try {
39558       result = (Dali::CustomActor *) &(arg1)->operator =((Dali::CustomActor const &)*arg2);
39559     } catch (std::out_of_range& e) {
39560       {
39561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39562       };
39563     } catch (std::exception& e) {
39564       {
39565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39566       };
39567     } catch (Dali::DaliException e) {
39568       {
39569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39570       };
39571     } catch (...) {
39572       {
39573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39574       };
39575     }
39576   }
39577
39578   jresult = (void *)result;
39579   return jresult;
39580 }
39581
39582
39583 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_POSITION_get() {
39584   int jresult ;
39585   int result;
39586
39587   result = (int)Dali::PanGestureDetector::Property::SCREEN_POSITION;
39588   jresult = (int)result;
39589   return jresult;
39590 }
39591
39592
39593 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_DISPLACEMENT_get() {
39594   int jresult ;
39595   int result;
39596
39597   result = (int)Dali::PanGestureDetector::Property::SCREEN_DISPLACEMENT;
39598   jresult = (int)result;
39599   return jresult;
39600 }
39601
39602
39603 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_SCREEN_VELOCITY_get() {
39604   int jresult ;
39605   int result;
39606
39607   result = (int)Dali::PanGestureDetector::Property::SCREEN_VELOCITY;
39608   jresult = (int)result;
39609   return jresult;
39610 }
39611
39612
39613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_POSITION_get() {
39614   int jresult ;
39615   int result;
39616
39617   result = (int)Dali::PanGestureDetector::Property::LOCAL_POSITION;
39618   jresult = (int)result;
39619   return jresult;
39620 }
39621
39622
39623 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_DISPLACEMENT_get() {
39624   int jresult ;
39625   int result;
39626
39627   result = (int)Dali::PanGestureDetector::Property::LOCAL_DISPLACEMENT;
39628   jresult = (int)result;
39629   return jresult;
39630 }
39631
39632
39633 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_LOCAL_VELOCITY_get() {
39634   int jresult ;
39635   int result;
39636
39637   result = (int)Dali::PanGestureDetector::Property::LOCAL_VELOCITY;
39638   jresult = (int)result;
39639   return jresult;
39640 }
39641
39642
39643 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PanGestureDetector_Property_PANNING_get() {
39644   int jresult ;
39645   int result;
39646
39647   result = (int)Dali::PanGestureDetector::Property::PANNING;
39648   jresult = (int)result;
39649   return jresult;
39650 }
39651
39652
39653 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector_Property() {
39654   void * jresult ;
39655   Dali::PanGestureDetector::Property *result = 0 ;
39656
39657   {
39658     try {
39659       result = (Dali::PanGestureDetector::Property *)new Dali::PanGestureDetector::Property();
39660     } catch (std::out_of_range& e) {
39661       {
39662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39663       };
39664     } catch (std::exception& e) {
39665       {
39666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39667       };
39668     } catch (Dali::DaliException e) {
39669       {
39670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39671       };
39672     } catch (...) {
39673       {
39674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39675       };
39676     }
39677   }
39678
39679   jresult = (void *)result;
39680   return jresult;
39681 }
39682
39683
39684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector_Property(void * jarg1) {
39685   Dali::PanGestureDetector::Property *arg1 = (Dali::PanGestureDetector::Property *) 0 ;
39686
39687   arg1 = (Dali::PanGestureDetector::Property *)jarg1;
39688   {
39689     try {
39690       delete arg1;
39691     } catch (std::out_of_range& e) {
39692       {
39693         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39694       };
39695     } catch (std::exception& e) {
39696       {
39697         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39698       };
39699     } catch (Dali::DaliException e) {
39700       {
39701         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39702       };
39703     } catch (...) {
39704       {
39705         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39706       };
39707     }
39708   }
39709
39710 }
39711
39712
39713 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_LEFT_get() {
39714   void * jresult ;
39715   Dali::Radian *result = 0 ;
39716
39717   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_LEFT;
39718   jresult = (void *)result;
39719   return jresult;
39720 }
39721
39722
39723 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_RIGHT_get() {
39724   void * jresult ;
39725   Dali::Radian *result = 0 ;
39726
39727   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_RIGHT;
39728   jresult = (void *)result;
39729   return jresult;
39730 }
39731
39732
39733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_UP_get() {
39734   void * jresult ;
39735   Dali::Radian *result = 0 ;
39736
39737   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_UP;
39738   jresult = (void *)result;
39739   return jresult;
39740 }
39741
39742
39743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_DOWN_get() {
39744   void * jresult ;
39745   Dali::Radian *result = 0 ;
39746
39747   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_DOWN;
39748   jresult = (void *)result;
39749   return jresult;
39750 }
39751
39752
39753 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_HORIZONTAL_get() {
39754   void * jresult ;
39755   Dali::Radian *result = 0 ;
39756
39757   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_HORIZONTAL;
39758   jresult = (void *)result;
39759   return jresult;
39760 }
39761
39762
39763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DIRECTION_VERTICAL_get() {
39764   void * jresult ;
39765   Dali::Radian *result = 0 ;
39766
39767   result = (Dali::Radian *)&Dali::PanGestureDetector::DIRECTION_VERTICAL;
39768   jresult = (void *)result;
39769   return jresult;
39770 }
39771
39772
39773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DEFAULT_THRESHOLD_get() {
39774   void * jresult ;
39775   Dali::Radian *result = 0 ;
39776
39777   result = (Dali::Radian *)&Dali::PanGestureDetector::DEFAULT_THRESHOLD;
39778   jresult = (void *)result;
39779   return jresult;
39780 }
39781
39782
39783 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_0() {
39784   void * jresult ;
39785   Dali::PanGestureDetector *result = 0 ;
39786
39787   {
39788     try {
39789       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector();
39790     } catch (std::out_of_range& e) {
39791       {
39792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39793       };
39794     } catch (std::exception& e) {
39795       {
39796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39797       };
39798     } catch (Dali::DaliException e) {
39799       {
39800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39801       };
39802     } catch (...) {
39803       {
39804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39805       };
39806     }
39807   }
39808
39809   jresult = (void *)result;
39810   return jresult;
39811 }
39812
39813
39814 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_New() {
39815   void * jresult ;
39816   Dali::PanGestureDetector result;
39817
39818   {
39819     try {
39820       result = Dali::PanGestureDetector::New();
39821     } catch (std::out_of_range& e) {
39822       {
39823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39824       };
39825     } catch (std::exception& e) {
39826       {
39827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39828       };
39829     } catch (Dali::DaliException e) {
39830       {
39831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39832       };
39833     } catch (...) {
39834       {
39835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39836       };
39837     }
39838   }
39839
39840   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39841   return jresult;
39842 }
39843
39844
39845 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DownCast(void * jarg1) {
39846   void * jresult ;
39847   Dali::BaseHandle arg1 ;
39848   Dali::BaseHandle *argp1 ;
39849   Dali::PanGestureDetector result;
39850
39851   argp1 = (Dali::BaseHandle *)jarg1;
39852   if (!argp1) {
39853     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
39854     return 0;
39855   }
39856   arg1 = *argp1;
39857   {
39858     try {
39859       result = Dali::PanGestureDetector::DownCast(arg1);
39860     } catch (std::out_of_range& e) {
39861       {
39862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39863       };
39864     } catch (std::exception& e) {
39865       {
39866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39867       };
39868     } catch (Dali::DaliException e) {
39869       {
39870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39871       };
39872     } catch (...) {
39873       {
39874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39875       };
39876     }
39877   }
39878
39879   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
39880   return jresult;
39881 }
39882
39883
39884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetector(void * jarg1) {
39885   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39886
39887   arg1 = (Dali::PanGestureDetector *)jarg1;
39888   {
39889     try {
39890       delete arg1;
39891     } catch (std::out_of_range& e) {
39892       {
39893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
39894       };
39895     } catch (std::exception& e) {
39896       {
39897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
39898       };
39899     } catch (Dali::DaliException e) {
39900       {
39901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
39902       };
39903     } catch (...) {
39904       {
39905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
39906       };
39907     }
39908   }
39909
39910 }
39911
39912
39913 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetector__SWIG_1(void * jarg1) {
39914   void * jresult ;
39915   Dali::PanGestureDetector *arg1 = 0 ;
39916   Dali::PanGestureDetector *result = 0 ;
39917
39918   arg1 = (Dali::PanGestureDetector *)jarg1;
39919   if (!arg1) {
39920     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39921     return 0;
39922   }
39923   {
39924     try {
39925       result = (Dali::PanGestureDetector *)new Dali::PanGestureDetector((Dali::PanGestureDetector const &)*arg1);
39926     } catch (std::out_of_range& e) {
39927       {
39928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39929       };
39930     } catch (std::exception& e) {
39931       {
39932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39933       };
39934     } catch (Dali::DaliException e) {
39935       {
39936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39937       };
39938     } catch (...) {
39939       {
39940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39941       };
39942     }
39943   }
39944
39945   jresult = (void *)result;
39946   return jresult;
39947 }
39948
39949
39950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_Assign(void * jarg1, void * jarg2) {
39951   void * jresult ;
39952   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39953   Dali::PanGestureDetector *arg2 = 0 ;
39954   Dali::PanGestureDetector *result = 0 ;
39955
39956   arg1 = (Dali::PanGestureDetector *)jarg1;
39957   arg2 = (Dali::PanGestureDetector *)jarg2;
39958   if (!arg2) {
39959     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGestureDetector const & type is null", 0);
39960     return 0;
39961   }
39962   {
39963     try {
39964       result = (Dali::PanGestureDetector *) &(arg1)->operator =((Dali::PanGestureDetector const &)*arg2);
39965     } catch (std::out_of_range& e) {
39966       {
39967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
39968       };
39969     } catch (std::exception& e) {
39970       {
39971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
39972       };
39973     } catch (Dali::DaliException e) {
39974       {
39975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
39976       };
39977     } catch (...) {
39978       {
39979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
39980       };
39981     }
39982   }
39983
39984   jresult = (void *)result;
39985   return jresult;
39986 }
39987
39988
39989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMinimumTouchesRequired(void * jarg1, unsigned int jarg2) {
39990   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
39991   unsigned int arg2 ;
39992
39993   arg1 = (Dali::PanGestureDetector *)jarg1;
39994   arg2 = (unsigned int)jarg2;
39995   {
39996     try {
39997       (arg1)->SetMinimumTouchesRequired(arg2);
39998     } catch (std::out_of_range& e) {
39999       {
40000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40001       };
40002     } catch (std::exception& e) {
40003       {
40004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40005       };
40006     } catch (Dali::DaliException e) {
40007       {
40008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40009       };
40010     } catch (...) {
40011       {
40012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40013       };
40014     }
40015   }
40016
40017 }
40018
40019
40020 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_SetMaximumTouchesRequired(void * jarg1, unsigned int jarg2) {
40021   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40022   unsigned int arg2 ;
40023
40024   arg1 = (Dali::PanGestureDetector *)jarg1;
40025   arg2 = (unsigned int)jarg2;
40026   {
40027     try {
40028       (arg1)->SetMaximumTouchesRequired(arg2);
40029     } catch (std::out_of_range& e) {
40030       {
40031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40032       };
40033     } catch (std::exception& e) {
40034       {
40035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40036       };
40037     } catch (Dali::DaliException e) {
40038       {
40039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40040       };
40041     } catch (...) {
40042       {
40043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40044       };
40045     }
40046   }
40047
40048 }
40049
40050
40051 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMinimumTouchesRequired(void * jarg1) {
40052   unsigned int jresult ;
40053   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40054   unsigned int result;
40055
40056   arg1 = (Dali::PanGestureDetector *)jarg1;
40057   {
40058     try {
40059       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMinimumTouchesRequired();
40060     } catch (std::out_of_range& e) {
40061       {
40062         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40063       };
40064     } catch (std::exception& e) {
40065       {
40066         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40067       };
40068     } catch (Dali::DaliException e) {
40069       {
40070         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40071       };
40072     } catch (...) {
40073       {
40074         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40075       };
40076     }
40077   }
40078
40079   jresult = result;
40080   return jresult;
40081 }
40082
40083
40084 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetMaximumTouchesRequired(void * jarg1) {
40085   unsigned int jresult ;
40086   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40087   unsigned int result;
40088
40089   arg1 = (Dali::PanGestureDetector *)jarg1;
40090   {
40091     try {
40092       result = (unsigned int)((Dali::PanGestureDetector const *)arg1)->GetMaximumTouchesRequired();
40093     } catch (std::out_of_range& e) {
40094       {
40095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40096       };
40097     } catch (std::exception& e) {
40098       {
40099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40100       };
40101     } catch (Dali::DaliException e) {
40102       {
40103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40104       };
40105     } catch (...) {
40106       {
40107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40108       };
40109     }
40110   }
40111
40112   jresult = result;
40113   return jresult;
40114 }
40115
40116
40117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40118   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40119   Dali::Radian arg2 ;
40120   Dali::Radian arg3 ;
40121   Dali::Radian *argp2 ;
40122   Dali::Radian *argp3 ;
40123
40124   arg1 = (Dali::PanGestureDetector *)jarg1;
40125   argp2 = (Dali::Radian *)jarg2;
40126   if (!argp2) {
40127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40128     return ;
40129   }
40130   arg2 = *argp2;
40131   argp3 = (Dali::Radian *)jarg3;
40132   if (!argp3) {
40133     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40134     return ;
40135   }
40136   arg3 = *argp3;
40137   {
40138     try {
40139       (arg1)->AddAngle(arg2,arg3);
40140     } catch (std::out_of_range& e) {
40141       {
40142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40143       };
40144     } catch (std::exception& e) {
40145       {
40146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40147       };
40148     } catch (Dali::DaliException e) {
40149       {
40150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40151       };
40152     } catch (...) {
40153       {
40154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40155       };
40156     }
40157   }
40158
40159 }
40160
40161
40162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddAngle__SWIG_1(void * jarg1, void * jarg2) {
40163   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40164   Dali::Radian arg2 ;
40165   Dali::Radian *argp2 ;
40166
40167   arg1 = (Dali::PanGestureDetector *)jarg1;
40168   argp2 = (Dali::Radian *)jarg2;
40169   if (!argp2) {
40170     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40171     return ;
40172   }
40173   arg2 = *argp2;
40174   {
40175     try {
40176       (arg1)->AddAngle(arg2);
40177     } catch (std::out_of_range& e) {
40178       {
40179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40180       };
40181     } catch (std::exception& e) {
40182       {
40183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40184       };
40185     } catch (Dali::DaliException e) {
40186       {
40187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40188       };
40189     } catch (...) {
40190       {
40191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40192       };
40193     }
40194   }
40195
40196 }
40197
40198
40199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
40200   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40201   Dali::Radian arg2 ;
40202   Dali::Radian arg3 ;
40203   Dali::Radian *argp2 ;
40204   Dali::Radian *argp3 ;
40205
40206   arg1 = (Dali::PanGestureDetector *)jarg1;
40207   argp2 = (Dali::Radian *)jarg2;
40208   if (!argp2) {
40209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40210     return ;
40211   }
40212   arg2 = *argp2;
40213   argp3 = (Dali::Radian *)jarg3;
40214   if (!argp3) {
40215     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40216     return ;
40217   }
40218   arg3 = *argp3;
40219   {
40220     try {
40221       (arg1)->AddDirection(arg2,arg3);
40222     } catch (std::out_of_range& e) {
40223       {
40224         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40225       };
40226     } catch (std::exception& e) {
40227       {
40228         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40229       };
40230     } catch (Dali::DaliException e) {
40231       {
40232         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40233       };
40234     } catch (...) {
40235       {
40236         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40237       };
40238     }
40239   }
40240
40241 }
40242
40243
40244 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_AddDirection__SWIG_1(void * jarg1, void * jarg2) {
40245   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40246   Dali::Radian arg2 ;
40247   Dali::Radian *argp2 ;
40248
40249   arg1 = (Dali::PanGestureDetector *)jarg1;
40250   argp2 = (Dali::Radian *)jarg2;
40251   if (!argp2) {
40252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40253     return ;
40254   }
40255   arg2 = *argp2;
40256   {
40257     try {
40258       (arg1)->AddDirection(arg2);
40259     } catch (std::out_of_range& e) {
40260       {
40261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40262       };
40263     } catch (std::exception& e) {
40264       {
40265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40266       };
40267     } catch (Dali::DaliException e) {
40268       {
40269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40270       };
40271     } catch (...) {
40272       {
40273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40274       };
40275     }
40276   }
40277
40278 }
40279
40280
40281 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngleCount(void * jarg1) {
40282   unsigned long jresult ;
40283   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40284   size_t result;
40285
40286   arg1 = (Dali::PanGestureDetector *)jarg1;
40287   {
40288     try {
40289       result = ((Dali::PanGestureDetector const *)arg1)->GetAngleCount();
40290     } catch (std::out_of_range& e) {
40291       {
40292         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40293       };
40294     } catch (std::exception& e) {
40295       {
40296         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40297       };
40298     } catch (Dali::DaliException e) {
40299       {
40300         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40301       };
40302     } catch (...) {
40303       {
40304         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40305       };
40306     }
40307   }
40308
40309   jresult = (unsigned long)result;
40310   return jresult;
40311 }
40312
40313
40314 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_GetAngle(void * jarg1, unsigned long jarg2) {
40315   void * jresult ;
40316   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40317   size_t arg2 ;
40318   Dali::PanGestureDetector::AngleThresholdPair result;
40319
40320   arg1 = (Dali::PanGestureDetector *)jarg1;
40321   arg2 = (size_t)jarg2;
40322   {
40323     try {
40324       result = ((Dali::PanGestureDetector const *)arg1)->GetAngle(arg2);
40325     } catch (std::out_of_range& e) {
40326       {
40327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40328       };
40329     } catch (std::exception& e) {
40330       {
40331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40332       };
40333     } catch (Dali::DaliException e) {
40334       {
40335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40336       };
40337     } catch (...) {
40338       {
40339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40340       };
40341     }
40342   }
40343
40344   jresult = new Dali::PanGestureDetector::AngleThresholdPair((const Dali::PanGestureDetector::AngleThresholdPair &)result);
40345   return jresult;
40346 }
40347
40348
40349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_ClearAngles(void * jarg1) {
40350   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40351
40352   arg1 = (Dali::PanGestureDetector *)jarg1;
40353   {
40354     try {
40355       (arg1)->ClearAngles();
40356     } catch (std::out_of_range& e) {
40357       {
40358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40359       };
40360     } catch (std::exception& e) {
40361       {
40362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40363       };
40364     } catch (Dali::DaliException e) {
40365       {
40366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40367       };
40368     } catch (...) {
40369       {
40370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40371       };
40372     }
40373   }
40374
40375 }
40376
40377
40378 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveAngle(void * jarg1, void * jarg2) {
40379   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40380   Dali::Radian arg2 ;
40381   Dali::Radian *argp2 ;
40382
40383   arg1 = (Dali::PanGestureDetector *)jarg1;
40384   argp2 = (Dali::Radian *)jarg2;
40385   if (!argp2) {
40386     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40387     return ;
40388   }
40389   arg2 = *argp2;
40390   {
40391     try {
40392       (arg1)->RemoveAngle(arg2);
40393     } catch (std::out_of_range& e) {
40394       {
40395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40396       };
40397     } catch (std::exception& e) {
40398       {
40399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40400       };
40401     } catch (Dali::DaliException e) {
40402       {
40403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40404       };
40405     } catch (...) {
40406       {
40407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40408       };
40409     }
40410   }
40411
40412 }
40413
40414
40415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetector_RemoveDirection(void * jarg1, void * jarg2) {
40416   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40417   Dali::Radian arg2 ;
40418   Dali::Radian *argp2 ;
40419
40420   arg1 = (Dali::PanGestureDetector *)jarg1;
40421   argp2 = (Dali::Radian *)jarg2;
40422   if (!argp2) {
40423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
40424     return ;
40425   }
40426   arg2 = *argp2;
40427   {
40428     try {
40429       (arg1)->RemoveDirection(arg2);
40430     } catch (std::out_of_range& e) {
40431       {
40432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40433       };
40434     } catch (std::exception& e) {
40435       {
40436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40437       };
40438     } catch (Dali::DaliException e) {
40439       {
40440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40441       };
40442     } catch (...) {
40443       {
40444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40445       };
40446     }
40447   }
40448
40449 }
40450
40451
40452 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGestureDetector_DetectedSignal(void * jarg1) {
40453   void * jresult ;
40454   Dali::PanGestureDetector *arg1 = (Dali::PanGestureDetector *) 0 ;
40455   Dali::PanGestureDetector::DetectedSignalType *result = 0 ;
40456
40457   arg1 = (Dali::PanGestureDetector *)jarg1;
40458   {
40459     try {
40460       result = (Dali::PanGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
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_SetPanGestureProperties(void * jarg1) {
40486   Dali::PanGesture *arg1 = 0 ;
40487
40488   arg1 = (Dali::PanGesture *)jarg1;
40489   if (!arg1) {
40490     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40491     return ;
40492   }
40493   {
40494     try {
40495       Dali::PanGestureDetector::SetPanGestureProperties((Dali::PanGesture const &)*arg1);
40496     } catch (std::out_of_range& e) {
40497       {
40498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40499       };
40500     } catch (std::exception& e) {
40501       {
40502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40503       };
40504     } catch (Dali::DaliException e) {
40505       {
40506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40507       };
40508     } catch (...) {
40509       {
40510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40511       };
40512     }
40513   }
40514
40515 }
40516
40517
40518 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_0() {
40519   void * jresult ;
40520   Dali::PanGesture *result = 0 ;
40521
40522   {
40523     try {
40524       result = (Dali::PanGesture *)new Dali::PanGesture();
40525     } catch (std::out_of_range& e) {
40526       {
40527         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40528       };
40529     } catch (std::exception& e) {
40530       {
40531         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40532       };
40533     } catch (Dali::DaliException e) {
40534       {
40535         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40536       };
40537     } catch (...) {
40538       {
40539         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40540       };
40541     }
40542   }
40543
40544   jresult = (void *)result;
40545   return jresult;
40546 }
40547
40548
40549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_1(int jarg1) {
40550   void * jresult ;
40551   Dali::Gesture::State arg1 ;
40552   Dali::PanGesture *result = 0 ;
40553
40554   arg1 = (Dali::Gesture::State)jarg1;
40555   {
40556     try {
40557       result = (Dali::PanGesture *)new Dali::PanGesture(arg1);
40558     } catch (std::out_of_range& e) {
40559       {
40560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40561       };
40562     } catch (std::exception& e) {
40563       {
40564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40565       };
40566     } catch (Dali::DaliException e) {
40567       {
40568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40569       };
40570     } catch (...) {
40571       {
40572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40573       };
40574     }
40575   }
40576
40577   jresult = (void *)result;
40578   return jresult;
40579 }
40580
40581
40582 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGesture__SWIG_2(void * jarg1) {
40583   void * jresult ;
40584   Dali::PanGesture *arg1 = 0 ;
40585   Dali::PanGesture *result = 0 ;
40586
40587   arg1 = (Dali::PanGesture *)jarg1;
40588   if (!arg1) {
40589     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40590     return 0;
40591   }
40592   {
40593     try {
40594       result = (Dali::PanGesture *)new Dali::PanGesture((Dali::PanGesture const &)*arg1);
40595     } catch (std::out_of_range& e) {
40596       {
40597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40598       };
40599     } catch (std::exception& e) {
40600       {
40601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40602       };
40603     } catch (Dali::DaliException e) {
40604       {
40605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40606       };
40607     } catch (...) {
40608       {
40609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40610       };
40611     }
40612   }
40613
40614   jresult = (void *)result;
40615   return jresult;
40616 }
40617
40618
40619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_Assign(void * jarg1, void * jarg2) {
40620   void * jresult ;
40621   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40622   Dali::PanGesture *arg2 = 0 ;
40623   Dali::PanGesture *result = 0 ;
40624
40625   arg1 = (Dali::PanGesture *)jarg1;
40626   arg2 = (Dali::PanGesture *)jarg2;
40627   if (!arg2) {
40628     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
40629     return 0;
40630   }
40631   {
40632     try {
40633       result = (Dali::PanGesture *) &(arg1)->operator =((Dali::PanGesture const &)*arg2);
40634     } catch (std::out_of_range& e) {
40635       {
40636         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40637       };
40638     } catch (std::exception& e) {
40639       {
40640         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40641       };
40642     } catch (Dali::DaliException e) {
40643       {
40644         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40645       };
40646     } catch (...) {
40647       {
40648         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40649       };
40650     }
40651   }
40652
40653   jresult = (void *)result;
40654   return jresult;
40655 }
40656
40657
40658 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGesture(void * jarg1) {
40659   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40660
40661   arg1 = (Dali::PanGesture *)jarg1;
40662   {
40663     try {
40664       delete arg1;
40665     } catch (std::out_of_range& e) {
40666       {
40667         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
40668       };
40669     } catch (std::exception& e) {
40670       {
40671         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
40672       };
40673     } catch (Dali::DaliException e) {
40674       {
40675         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
40676       };
40677     } catch (...) {
40678       {
40679         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
40680       };
40681     }
40682   }
40683
40684 }
40685
40686
40687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_velocity_set(void * jarg1, void * jarg2) {
40688   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40689   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40690
40691   arg1 = (Dali::PanGesture *)jarg1;
40692   arg2 = (Dali::Vector2 *)jarg2;
40693   if (arg1) (arg1)->velocity = *arg2;
40694 }
40695
40696
40697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_velocity_get(void * jarg1) {
40698   void * jresult ;
40699   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40700   Dali::Vector2 *result = 0 ;
40701
40702   arg1 = (Dali::PanGesture *)jarg1;
40703   result = (Dali::Vector2 *)& ((arg1)->velocity);
40704   jresult = (void *)result;
40705   return jresult;
40706 }
40707
40708
40709 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_displacement_set(void * jarg1, void * jarg2) {
40710   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40711   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40712
40713   arg1 = (Dali::PanGesture *)jarg1;
40714   arg2 = (Dali::Vector2 *)jarg2;
40715   if (arg1) (arg1)->displacement = *arg2;
40716 }
40717
40718
40719 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_displacement_get(void * jarg1) {
40720   void * jresult ;
40721   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40722   Dali::Vector2 *result = 0 ;
40723
40724   arg1 = (Dali::PanGesture *)jarg1;
40725   result = (Dali::Vector2 *)& ((arg1)->displacement);
40726   jresult = (void *)result;
40727   return jresult;
40728 }
40729
40730
40731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_position_set(void * jarg1, void * jarg2) {
40732   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40733   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40734
40735   arg1 = (Dali::PanGesture *)jarg1;
40736   arg2 = (Dali::Vector2 *)jarg2;
40737   if (arg1) (arg1)->position = *arg2;
40738 }
40739
40740
40741 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_position_get(void * jarg1) {
40742   void * jresult ;
40743   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40744   Dali::Vector2 *result = 0 ;
40745
40746   arg1 = (Dali::PanGesture *)jarg1;
40747   result = (Dali::Vector2 *)& ((arg1)->position);
40748   jresult = (void *)result;
40749   return jresult;
40750 }
40751
40752
40753 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_set(void * jarg1, void * jarg2) {
40754   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40755   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40756
40757   arg1 = (Dali::PanGesture *)jarg1;
40758   arg2 = (Dali::Vector2 *)jarg2;
40759   if (arg1) (arg1)->screenVelocity = *arg2;
40760 }
40761
40762
40763 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenVelocity_get(void * jarg1) {
40764   void * jresult ;
40765   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40766   Dali::Vector2 *result = 0 ;
40767
40768   arg1 = (Dali::PanGesture *)jarg1;
40769   result = (Dali::Vector2 *)& ((arg1)->screenVelocity);
40770   jresult = (void *)result;
40771   return jresult;
40772 }
40773
40774
40775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_set(void * jarg1, void * jarg2) {
40776   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40777   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40778
40779   arg1 = (Dali::PanGesture *)jarg1;
40780   arg2 = (Dali::Vector2 *)jarg2;
40781   if (arg1) (arg1)->screenDisplacement = *arg2;
40782 }
40783
40784
40785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenDisplacement_get(void * jarg1) {
40786   void * jresult ;
40787   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40788   Dali::Vector2 *result = 0 ;
40789
40790   arg1 = (Dali::PanGesture *)jarg1;
40791   result = (Dali::Vector2 *)& ((arg1)->screenDisplacement);
40792   jresult = (void *)result;
40793   return jresult;
40794 }
40795
40796
40797 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_set(void * jarg1, void * jarg2) {
40798   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40799   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
40800
40801   arg1 = (Dali::PanGesture *)jarg1;
40802   arg2 = (Dali::Vector2 *)jarg2;
40803   if (arg1) (arg1)->screenPosition = *arg2;
40804 }
40805
40806
40807 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PanGesture_screenPosition_get(void * jarg1) {
40808   void * jresult ;
40809   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40810   Dali::Vector2 *result = 0 ;
40811
40812   arg1 = (Dali::PanGesture *)jarg1;
40813   result = (Dali::Vector2 *)& ((arg1)->screenPosition);
40814   jresult = (void *)result;
40815   return jresult;
40816 }
40817
40818
40819 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
40820   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40821   unsigned int arg2 ;
40822
40823   arg1 = (Dali::PanGesture *)jarg1;
40824   arg2 = (unsigned int)jarg2;
40825   if (arg1) (arg1)->numberOfTouches = arg2;
40826 }
40827
40828
40829 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGesture_numberOfTouches_get(void * jarg1) {
40830   unsigned int jresult ;
40831   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40832   unsigned int result;
40833
40834   arg1 = (Dali::PanGesture *)jarg1;
40835   result = (unsigned int) ((arg1)->numberOfTouches);
40836   jresult = result;
40837   return jresult;
40838 }
40839
40840
40841 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetSpeed(void * jarg1) {
40842   float jresult ;
40843   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40844   float result;
40845
40846   arg1 = (Dali::PanGesture *)jarg1;
40847   {
40848     try {
40849       result = (float)((Dali::PanGesture const *)arg1)->GetSpeed();
40850     } catch (std::out_of_range& e) {
40851       {
40852         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40853       };
40854     } catch (std::exception& e) {
40855       {
40856         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40857       };
40858     } catch (Dali::DaliException e) {
40859       {
40860         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40861       };
40862     } catch (...) {
40863       {
40864         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40865       };
40866     }
40867   }
40868
40869   jresult = result;
40870   return jresult;
40871 }
40872
40873
40874 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetDistance(void * jarg1) {
40875   float jresult ;
40876   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40877   float result;
40878
40879   arg1 = (Dali::PanGesture *)jarg1;
40880   {
40881     try {
40882       result = (float)((Dali::PanGesture const *)arg1)->GetDistance();
40883     } catch (std::out_of_range& e) {
40884       {
40885         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40886       };
40887     } catch (std::exception& e) {
40888       {
40889         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40890       };
40891     } catch (Dali::DaliException e) {
40892       {
40893         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40894       };
40895     } catch (...) {
40896       {
40897         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40898       };
40899     }
40900   }
40901
40902   jresult = result;
40903   return jresult;
40904 }
40905
40906
40907 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenSpeed(void * jarg1) {
40908   float jresult ;
40909   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40910   float result;
40911
40912   arg1 = (Dali::PanGesture *)jarg1;
40913   {
40914     try {
40915       result = (float)((Dali::PanGesture const *)arg1)->GetScreenSpeed();
40916     } catch (std::out_of_range& e) {
40917       {
40918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40919       };
40920     } catch (std::exception& e) {
40921       {
40922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40923       };
40924     } catch (Dali::DaliException e) {
40925       {
40926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40927       };
40928     } catch (...) {
40929       {
40930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40931       };
40932     }
40933   }
40934
40935   jresult = result;
40936   return jresult;
40937 }
40938
40939
40940 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PanGesture_GetScreenDistance(void * jarg1) {
40941   float jresult ;
40942   Dali::PanGesture *arg1 = (Dali::PanGesture *) 0 ;
40943   float result;
40944
40945   arg1 = (Dali::PanGesture *)jarg1;
40946   {
40947     try {
40948       result = (float)((Dali::PanGesture const *)arg1)->GetScreenDistance();
40949     } catch (std::out_of_range& e) {
40950       {
40951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40952       };
40953     } catch (std::exception& e) {
40954       {
40955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40956       };
40957     } catch (Dali::DaliException e) {
40958       {
40959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40960       };
40961     } catch (...) {
40962       {
40963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40964       };
40965     }
40966   }
40967
40968   jresult = result;
40969   return jresult;
40970 }
40971
40972
40973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_0() {
40974   void * jresult ;
40975   Dali::PinchGestureDetector *result = 0 ;
40976
40977   {
40978     try {
40979       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector();
40980     } catch (std::out_of_range& e) {
40981       {
40982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
40983       };
40984     } catch (std::exception& e) {
40985       {
40986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
40987       };
40988     } catch (Dali::DaliException e) {
40989       {
40990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
40991       };
40992     } catch (...) {
40993       {
40994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
40995       };
40996     }
40997   }
40998
40999   jresult = (void *)result;
41000   return jresult;
41001 }
41002
41003
41004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_New() {
41005   void * jresult ;
41006   Dali::PinchGestureDetector result;
41007
41008   {
41009     try {
41010       result = Dali::PinchGestureDetector::New();
41011     } catch (std::out_of_range& e) {
41012       {
41013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41014       };
41015     } catch (std::exception& e) {
41016       {
41017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41018       };
41019     } catch (Dali::DaliException e) {
41020       {
41021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41022       };
41023     } catch (...) {
41024       {
41025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41026       };
41027     }
41028   }
41029
41030   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41031   return jresult;
41032 }
41033
41034
41035 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DownCast(void * jarg1) {
41036   void * jresult ;
41037   Dali::BaseHandle arg1 ;
41038   Dali::BaseHandle *argp1 ;
41039   Dali::PinchGestureDetector result;
41040
41041   argp1 = (Dali::BaseHandle *)jarg1;
41042   if (!argp1) {
41043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41044     return 0;
41045   }
41046   arg1 = *argp1;
41047   {
41048     try {
41049       result = Dali::PinchGestureDetector::DownCast(arg1);
41050     } catch (std::out_of_range& e) {
41051       {
41052         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41053       };
41054     } catch (std::exception& e) {
41055       {
41056         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41057       };
41058     } catch (Dali::DaliException e) {
41059       {
41060         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41061       };
41062     } catch (...) {
41063       {
41064         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41065       };
41066     }
41067   }
41068
41069   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
41070   return jresult;
41071 }
41072
41073
41074 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetector(void * jarg1) {
41075   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41076
41077   arg1 = (Dali::PinchGestureDetector *)jarg1;
41078   {
41079     try {
41080       delete arg1;
41081     } catch (std::out_of_range& e) {
41082       {
41083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41084       };
41085     } catch (std::exception& e) {
41086       {
41087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41088       };
41089     } catch (Dali::DaliException e) {
41090       {
41091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41092       };
41093     } catch (...) {
41094       {
41095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41096       };
41097     }
41098   }
41099
41100 }
41101
41102
41103 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetector__SWIG_1(void * jarg1) {
41104   void * jresult ;
41105   Dali::PinchGestureDetector *arg1 = 0 ;
41106   Dali::PinchGestureDetector *result = 0 ;
41107
41108   arg1 = (Dali::PinchGestureDetector *)jarg1;
41109   if (!arg1) {
41110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41111     return 0;
41112   }
41113   {
41114     try {
41115       result = (Dali::PinchGestureDetector *)new Dali::PinchGestureDetector((Dali::PinchGestureDetector const &)*arg1);
41116     } catch (std::out_of_range& e) {
41117       {
41118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41119       };
41120     } catch (std::exception& e) {
41121       {
41122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41123       };
41124     } catch (Dali::DaliException e) {
41125       {
41126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41127       };
41128     } catch (...) {
41129       {
41130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41131       };
41132     }
41133   }
41134
41135   jresult = (void *)result;
41136   return jresult;
41137 }
41138
41139
41140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_Assign(void * jarg1, void * jarg2) {
41141   void * jresult ;
41142   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41143   Dali::PinchGestureDetector *arg2 = 0 ;
41144   Dali::PinchGestureDetector *result = 0 ;
41145
41146   arg1 = (Dali::PinchGestureDetector *)jarg1;
41147   arg2 = (Dali::PinchGestureDetector *)jarg2;
41148   if (!arg2) {
41149     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGestureDetector const & type is null", 0);
41150     return 0;
41151   }
41152   {
41153     try {
41154       result = (Dali::PinchGestureDetector *) &(arg1)->operator =((Dali::PinchGestureDetector const &)*arg2);
41155     } catch (std::out_of_range& e) {
41156       {
41157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41158       };
41159     } catch (std::exception& e) {
41160       {
41161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41162       };
41163     } catch (Dali::DaliException e) {
41164       {
41165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41166       };
41167     } catch (...) {
41168       {
41169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41170       };
41171     }
41172   }
41173
41174   jresult = (void *)result;
41175   return jresult;
41176 }
41177
41178
41179 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_DetectedSignal(void * jarg1) {
41180   void * jresult ;
41181   Dali::PinchGestureDetector *arg1 = (Dali::PinchGestureDetector *) 0 ;
41182   Dali::PinchGestureDetector::DetectedSignalType *result = 0 ;
41183
41184   arg1 = (Dali::PinchGestureDetector *)jarg1;
41185   {
41186     try {
41187       result = (Dali::PinchGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41188     } catch (std::out_of_range& e) {
41189       {
41190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41191       };
41192     } catch (std::exception& e) {
41193       {
41194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41195       };
41196     } catch (Dali::DaliException e) {
41197       {
41198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41199       };
41200     } catch (...) {
41201       {
41202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41203       };
41204     }
41205   }
41206
41207   jresult = (void *)result;
41208   return jresult;
41209 }
41210
41211
41212 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_0(int jarg1) {
41213   void * jresult ;
41214   Dali::Gesture::State arg1 ;
41215   Dali::PinchGesture *result = 0 ;
41216
41217   arg1 = (Dali::Gesture::State)jarg1;
41218   {
41219     try {
41220       result = (Dali::PinchGesture *)new Dali::PinchGesture(arg1);
41221     } catch (std::out_of_range& e) {
41222       {
41223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41224       };
41225     } catch (std::exception& e) {
41226       {
41227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41228       };
41229     } catch (Dali::DaliException e) {
41230       {
41231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41232       };
41233     } catch (...) {
41234       {
41235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41236       };
41237     }
41238   }
41239
41240   jresult = (void *)result;
41241   return jresult;
41242 }
41243
41244
41245 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGesture__SWIG_1(void * jarg1) {
41246   void * jresult ;
41247   Dali::PinchGesture *arg1 = 0 ;
41248   Dali::PinchGesture *result = 0 ;
41249
41250   arg1 = (Dali::PinchGesture *)jarg1;
41251   if (!arg1) {
41252     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41253     return 0;
41254   }
41255   {
41256     try {
41257       result = (Dali::PinchGesture *)new Dali::PinchGesture((Dali::PinchGesture const &)*arg1);
41258     } catch (std::out_of_range& e) {
41259       {
41260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41261       };
41262     } catch (std::exception& e) {
41263       {
41264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41265       };
41266     } catch (Dali::DaliException e) {
41267       {
41268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41269       };
41270     } catch (...) {
41271       {
41272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41273       };
41274     }
41275   }
41276
41277   jresult = (void *)result;
41278   return jresult;
41279 }
41280
41281
41282 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_Assign(void * jarg1, void * jarg2) {
41283   void * jresult ;
41284   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41285   Dali::PinchGesture *arg2 = 0 ;
41286   Dali::PinchGesture *result = 0 ;
41287
41288   arg1 = (Dali::PinchGesture *)jarg1;
41289   arg2 = (Dali::PinchGesture *)jarg2;
41290   if (!arg2) {
41291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
41292     return 0;
41293   }
41294   {
41295     try {
41296       result = (Dali::PinchGesture *) &(arg1)->operator =((Dali::PinchGesture const &)*arg2);
41297     } catch (std::out_of_range& e) {
41298       {
41299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41300       };
41301     } catch (std::exception& e) {
41302       {
41303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41304       };
41305     } catch (Dali::DaliException e) {
41306       {
41307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41308       };
41309     } catch (...) {
41310       {
41311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41312       };
41313     }
41314   }
41315
41316   jresult = (void *)result;
41317   return jresult;
41318 }
41319
41320
41321 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGesture(void * jarg1) {
41322   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41323
41324   arg1 = (Dali::PinchGesture *)jarg1;
41325   {
41326     try {
41327       delete arg1;
41328     } catch (std::out_of_range& e) {
41329       {
41330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41331       };
41332     } catch (std::exception& e) {
41333       {
41334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41335       };
41336     } catch (Dali::DaliException e) {
41337       {
41338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41339       };
41340     } catch (...) {
41341       {
41342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41343       };
41344     }
41345   }
41346
41347 }
41348
41349
41350 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_scale_set(void * jarg1, float jarg2) {
41351   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41352   float arg2 ;
41353
41354   arg1 = (Dali::PinchGesture *)jarg1;
41355   arg2 = (float)jarg2;
41356   if (arg1) (arg1)->scale = arg2;
41357 }
41358
41359
41360 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_scale_get(void * jarg1) {
41361   float jresult ;
41362   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41363   float result;
41364
41365   arg1 = (Dali::PinchGesture *)jarg1;
41366   result = (float) ((arg1)->scale);
41367   jresult = result;
41368   return jresult;
41369 }
41370
41371
41372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_speed_set(void * jarg1, float jarg2) {
41373   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41374   float arg2 ;
41375
41376   arg1 = (Dali::PinchGesture *)jarg1;
41377   arg2 = (float)jarg2;
41378   if (arg1) (arg1)->speed = arg2;
41379 }
41380
41381
41382 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PinchGesture_speed_get(void * jarg1) {
41383   float jresult ;
41384   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41385   float result;
41386
41387   arg1 = (Dali::PinchGesture *)jarg1;
41388   result = (float) ((arg1)->speed);
41389   jresult = result;
41390   return jresult;
41391 }
41392
41393
41394 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_set(void * jarg1, void * jarg2) {
41395   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41396   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41397
41398   arg1 = (Dali::PinchGesture *)jarg1;
41399   arg2 = (Dali::Vector2 *)jarg2;
41400   if (arg1) (arg1)->screenCenterPoint = *arg2;
41401 }
41402
41403
41404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_screenCenterPoint_get(void * jarg1) {
41405   void * jresult ;
41406   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41407   Dali::Vector2 *result = 0 ;
41408
41409   arg1 = (Dali::PinchGesture *)jarg1;
41410   result = (Dali::Vector2 *)& ((arg1)->screenCenterPoint);
41411   jresult = (void *)result;
41412   return jresult;
41413 }
41414
41415
41416 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_set(void * jarg1, void * jarg2) {
41417   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41418   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
41419
41420   arg1 = (Dali::PinchGesture *)jarg1;
41421   arg2 = (Dali::Vector2 *)jarg2;
41422   if (arg1) (arg1)->localCenterPoint = *arg2;
41423 }
41424
41425
41426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PinchGesture_localCenterPoint_get(void * jarg1) {
41427   void * jresult ;
41428   Dali::PinchGesture *arg1 = (Dali::PinchGesture *) 0 ;
41429   Dali::Vector2 *result = 0 ;
41430
41431   arg1 = (Dali::PinchGesture *)jarg1;
41432   result = (Dali::Vector2 *)& ((arg1)->localCenterPoint);
41433   jresult = (void *)result;
41434   return jresult;
41435 }
41436
41437
41438 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_0() {
41439   void * jresult ;
41440   Dali::TapGestureDetector *result = 0 ;
41441
41442   {
41443     try {
41444       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector();
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 = (void *)result;
41465   return jresult;
41466 }
41467
41468
41469 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_0() {
41470   void * jresult ;
41471   Dali::TapGestureDetector result;
41472
41473   {
41474     try {
41475       result = Dali::TapGestureDetector::New();
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 = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41496   return jresult;
41497 }
41498
41499
41500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_New__SWIG_1(unsigned int jarg1) {
41501   void * jresult ;
41502   unsigned int arg1 ;
41503   Dali::TapGestureDetector result;
41504
41505   arg1 = (unsigned int)jarg1;
41506   {
41507     try {
41508       result = Dali::TapGestureDetector::New(arg1);
41509     } catch (std::out_of_range& e) {
41510       {
41511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41512       };
41513     } catch (std::exception& e) {
41514       {
41515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41516       };
41517     } catch (Dali::DaliException e) {
41518       {
41519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41520       };
41521     } catch (...) {
41522       {
41523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41524       };
41525     }
41526   }
41527
41528   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41529   return jresult;
41530 }
41531
41532
41533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DownCast(void * jarg1) {
41534   void * jresult ;
41535   Dali::BaseHandle arg1 ;
41536   Dali::BaseHandle *argp1 ;
41537   Dali::TapGestureDetector result;
41538
41539   argp1 = (Dali::BaseHandle *)jarg1;
41540   if (!argp1) {
41541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
41542     return 0;
41543   }
41544   arg1 = *argp1;
41545   {
41546     try {
41547       result = Dali::TapGestureDetector::DownCast(arg1);
41548     } catch (std::out_of_range& e) {
41549       {
41550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41551       };
41552     } catch (std::exception& e) {
41553       {
41554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41555       };
41556     } catch (Dali::DaliException e) {
41557       {
41558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41559       };
41560     } catch (...) {
41561       {
41562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41563       };
41564     }
41565   }
41566
41567   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
41568   return jresult;
41569 }
41570
41571
41572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetector(void * jarg1) {
41573   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41574
41575   arg1 = (Dali::TapGestureDetector *)jarg1;
41576   {
41577     try {
41578       delete arg1;
41579     } catch (std::out_of_range& e) {
41580       {
41581         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41582       };
41583     } catch (std::exception& e) {
41584       {
41585         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41586       };
41587     } catch (Dali::DaliException e) {
41588       {
41589         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41590       };
41591     } catch (...) {
41592       {
41593         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41594       };
41595     }
41596   }
41597
41598 }
41599
41600
41601 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetector__SWIG_1(void * jarg1) {
41602   void * jresult ;
41603   Dali::TapGestureDetector *arg1 = 0 ;
41604   Dali::TapGestureDetector *result = 0 ;
41605
41606   arg1 = (Dali::TapGestureDetector *)jarg1;
41607   if (!arg1) {
41608     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41609     return 0;
41610   }
41611   {
41612     try {
41613       result = (Dali::TapGestureDetector *)new Dali::TapGestureDetector((Dali::TapGestureDetector const &)*arg1);
41614     } catch (std::out_of_range& e) {
41615       {
41616         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41617       };
41618     } catch (std::exception& e) {
41619       {
41620         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41621       };
41622     } catch (Dali::DaliException e) {
41623       {
41624         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41625       };
41626     } catch (...) {
41627       {
41628         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41629       };
41630     }
41631   }
41632
41633   jresult = (void *)result;
41634   return jresult;
41635 }
41636
41637
41638 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_Assign(void * jarg1, void * jarg2) {
41639   void * jresult ;
41640   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41641   Dali::TapGestureDetector *arg2 = 0 ;
41642   Dali::TapGestureDetector *result = 0 ;
41643
41644   arg1 = (Dali::TapGestureDetector *)jarg1;
41645   arg2 = (Dali::TapGestureDetector *)jarg2;
41646   if (!arg2) {
41647     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGestureDetector const & type is null", 0);
41648     return 0;
41649   }
41650   {
41651     try {
41652       result = (Dali::TapGestureDetector *) &(arg1)->operator =((Dali::TapGestureDetector const &)*arg2);
41653     } catch (std::out_of_range& e) {
41654       {
41655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41656       };
41657     } catch (std::exception& e) {
41658       {
41659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41660       };
41661     } catch (Dali::DaliException e) {
41662       {
41663         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41664       };
41665     } catch (...) {
41666       {
41667         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41668       };
41669     }
41670   }
41671
41672   jresult = (void *)result;
41673   return jresult;
41674 }
41675
41676
41677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMinimumTapsRequired(void * jarg1, unsigned int jarg2) {
41678   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41679   unsigned int arg2 ;
41680
41681   arg1 = (Dali::TapGestureDetector *)jarg1;
41682   arg2 = (unsigned int)jarg2;
41683   {
41684     try {
41685       (arg1)->SetMinimumTapsRequired(arg2);
41686     } catch (std::out_of_range& e) {
41687       {
41688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41689       };
41690     } catch (std::exception& e) {
41691       {
41692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41693       };
41694     } catch (Dali::DaliException e) {
41695       {
41696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41697       };
41698     } catch (...) {
41699       {
41700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41701       };
41702     }
41703   }
41704
41705 }
41706
41707
41708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetector_SetMaximumTapsRequired(void * jarg1, unsigned int jarg2) {
41709   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41710   unsigned int arg2 ;
41711
41712   arg1 = (Dali::TapGestureDetector *)jarg1;
41713   arg2 = (unsigned int)jarg2;
41714   {
41715     try {
41716       (arg1)->SetMaximumTapsRequired(arg2);
41717     } catch (std::out_of_range& e) {
41718       {
41719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41720       };
41721     } catch (std::exception& e) {
41722       {
41723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41724       };
41725     } catch (Dali::DaliException e) {
41726       {
41727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41728       };
41729     } catch (...) {
41730       {
41731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41732       };
41733     }
41734   }
41735
41736 }
41737
41738
41739 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMinimumTapsRequired(void * jarg1) {
41740   unsigned int jresult ;
41741   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41742   unsigned int result;
41743
41744   arg1 = (Dali::TapGestureDetector *)jarg1;
41745   {
41746     try {
41747       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMinimumTapsRequired();
41748     } catch (std::out_of_range& e) {
41749       {
41750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41751       };
41752     } catch (std::exception& e) {
41753       {
41754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41755       };
41756     } catch (Dali::DaliException e) {
41757       {
41758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41759       };
41760     } catch (...) {
41761       {
41762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41763       };
41764     }
41765   }
41766
41767   jresult = result;
41768   return jresult;
41769 }
41770
41771
41772 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetector_GetMaximumTapsRequired(void * jarg1) {
41773   unsigned int jresult ;
41774   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41775   unsigned int result;
41776
41777   arg1 = (Dali::TapGestureDetector *)jarg1;
41778   {
41779     try {
41780       result = (unsigned int)((Dali::TapGestureDetector const *)arg1)->GetMaximumTapsRequired();
41781     } catch (std::out_of_range& e) {
41782       {
41783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41784       };
41785     } catch (std::exception& e) {
41786       {
41787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41788       };
41789     } catch (Dali::DaliException e) {
41790       {
41791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41792       };
41793     } catch (...) {
41794       {
41795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41796       };
41797     }
41798   }
41799
41800   jresult = result;
41801   return jresult;
41802 }
41803
41804
41805 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGestureDetector_DetectedSignal(void * jarg1) {
41806   void * jresult ;
41807   Dali::TapGestureDetector *arg1 = (Dali::TapGestureDetector *) 0 ;
41808   Dali::TapGestureDetector::DetectedSignalType *result = 0 ;
41809
41810   arg1 = (Dali::TapGestureDetector *)jarg1;
41811   {
41812     try {
41813       result = (Dali::TapGestureDetector::DetectedSignalType *) &(arg1)->DetectedSignal();
41814     } catch (std::out_of_range& e) {
41815       {
41816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41817       };
41818     } catch (std::exception& e) {
41819       {
41820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41821       };
41822     } catch (Dali::DaliException e) {
41823       {
41824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41825       };
41826     } catch (...) {
41827       {
41828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41829       };
41830     }
41831   }
41832
41833   jresult = (void *)result;
41834   return jresult;
41835 }
41836
41837
41838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_0() {
41839   void * jresult ;
41840   Dali::TapGesture *result = 0 ;
41841
41842   {
41843     try {
41844       result = (Dali::TapGesture *)new Dali::TapGesture();
41845     } catch (std::out_of_range& e) {
41846       {
41847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41848       };
41849     } catch (std::exception& e) {
41850       {
41851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41852       };
41853     } catch (Dali::DaliException e) {
41854       {
41855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41856       };
41857     } catch (...) {
41858       {
41859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41860       };
41861     }
41862   }
41863
41864   jresult = (void *)result;
41865   return jresult;
41866 }
41867
41868
41869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGesture__SWIG_1(void * jarg1) {
41870   void * jresult ;
41871   Dali::TapGesture *arg1 = 0 ;
41872   Dali::TapGesture *result = 0 ;
41873
41874   arg1 = (Dali::TapGesture *)jarg1;
41875   if (!arg1) {
41876     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41877     return 0;
41878   }
41879   {
41880     try {
41881       result = (Dali::TapGesture *)new Dali::TapGesture((Dali::TapGesture const &)*arg1);
41882     } catch (std::out_of_range& e) {
41883       {
41884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41885       };
41886     } catch (std::exception& e) {
41887       {
41888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41889       };
41890     } catch (Dali::DaliException e) {
41891       {
41892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41893       };
41894     } catch (...) {
41895       {
41896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41897       };
41898     }
41899   }
41900
41901   jresult = (void *)result;
41902   return jresult;
41903 }
41904
41905
41906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_Assign(void * jarg1, void * jarg2) {
41907   void * jresult ;
41908   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41909   Dali::TapGesture *arg2 = 0 ;
41910   Dali::TapGesture *result = 0 ;
41911
41912   arg1 = (Dali::TapGesture *)jarg1;
41913   arg2 = (Dali::TapGesture *)jarg2;
41914   if (!arg2) {
41915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
41916     return 0;
41917   }
41918   {
41919     try {
41920       result = (Dali::TapGesture *) &(arg1)->operator =((Dali::TapGesture const &)*arg2);
41921     } catch (std::out_of_range& e) {
41922       {
41923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
41924       };
41925     } catch (std::exception& e) {
41926       {
41927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
41928       };
41929     } catch (Dali::DaliException e) {
41930       {
41931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
41932       };
41933     } catch (...) {
41934       {
41935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
41936       };
41937     }
41938   }
41939
41940   jresult = (void *)result;
41941   return jresult;
41942 }
41943
41944
41945 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGesture(void * jarg1) {
41946   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41947
41948   arg1 = (Dali::TapGesture *)jarg1;
41949   {
41950     try {
41951       delete arg1;
41952     } catch (std::out_of_range& e) {
41953       {
41954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
41955       };
41956     } catch (std::exception& e) {
41957       {
41958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
41959       };
41960     } catch (Dali::DaliException e) {
41961       {
41962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
41963       };
41964     } catch (...) {
41965       {
41966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
41967       };
41968     }
41969   }
41970
41971 }
41972
41973
41974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_set(void * jarg1, unsigned int jarg2) {
41975   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41976   unsigned int arg2 ;
41977
41978   arg1 = (Dali::TapGesture *)jarg1;
41979   arg2 = (unsigned int)jarg2;
41980   if (arg1) (arg1)->numberOfTaps = arg2;
41981 }
41982
41983
41984 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTaps_get(void * jarg1) {
41985   unsigned int jresult ;
41986   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41987   unsigned int result;
41988
41989   arg1 = (Dali::TapGesture *)jarg1;
41990   result = (unsigned int) ((arg1)->numberOfTaps);
41991   jresult = result;
41992   return jresult;
41993 }
41994
41995
41996 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_set(void * jarg1, unsigned int jarg2) {
41997   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
41998   unsigned int arg2 ;
41999
42000   arg1 = (Dali::TapGesture *)jarg1;
42001   arg2 = (unsigned int)jarg2;
42002   if (arg1) (arg1)->numberOfTouches = arg2;
42003 }
42004
42005
42006 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGesture_numberOfTouches_get(void * jarg1) {
42007   unsigned int jresult ;
42008   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42009   unsigned int result;
42010
42011   arg1 = (Dali::TapGesture *)jarg1;
42012   result = (unsigned int) ((arg1)->numberOfTouches);
42013   jresult = result;
42014   return jresult;
42015 }
42016
42017
42018 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_set(void * jarg1, void * jarg2) {
42019   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42020   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42021
42022   arg1 = (Dali::TapGesture *)jarg1;
42023   arg2 = (Dali::Vector2 *)jarg2;
42024   if (arg1) (arg1)->screenPoint = *arg2;
42025 }
42026
42027
42028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_screenPoint_get(void * jarg1) {
42029   void * jresult ;
42030   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42031   Dali::Vector2 *result = 0 ;
42032
42033   arg1 = (Dali::TapGesture *)jarg1;
42034   result = (Dali::Vector2 *)& ((arg1)->screenPoint);
42035   jresult = (void *)result;
42036   return jresult;
42037 }
42038
42039
42040 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_set(void * jarg1, void * jarg2) {
42041   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42042   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
42043
42044   arg1 = (Dali::TapGesture *)jarg1;
42045   arg2 = (Dali::Vector2 *)jarg2;
42046   if (arg1) (arg1)->localPoint = *arg2;
42047 }
42048
42049
42050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TapGesture_localPoint_get(void * jarg1) {
42051   void * jresult ;
42052   Dali::TapGesture *arg1 = (Dali::TapGesture *) 0 ;
42053   Dali::Vector2 *result = 0 ;
42054
42055   arg1 = (Dali::TapGesture *)jarg1;
42056   result = (Dali::Vector2 *)& ((arg1)->localPoint);
42057   jresult = (void *)result;
42058   return jresult;
42059 }
42060
42061
42062 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_0() {
42063   void * jresult ;
42064   Dali::AlphaFunction *result = 0 ;
42065
42066   {
42067     try {
42068       result = (Dali::AlphaFunction *)new Dali::AlphaFunction();
42069     } catch (std::out_of_range& e) {
42070       {
42071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42072       };
42073     } catch (std::exception& e) {
42074       {
42075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42076       };
42077     } catch (Dali::DaliException e) {
42078       {
42079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42080       };
42081     } catch (...) {
42082       {
42083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42084       };
42085     }
42086   }
42087
42088   jresult = (void *)result;
42089   return jresult;
42090 }
42091
42092
42093 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_1(int jarg1) {
42094   void * jresult ;
42095   Dali::AlphaFunction::BuiltinFunction arg1 ;
42096   Dali::AlphaFunction *result = 0 ;
42097
42098   arg1 = (Dali::AlphaFunction::BuiltinFunction)jarg1;
42099   {
42100     try {
42101       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42102     } catch (std::out_of_range& e) {
42103       {
42104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42105       };
42106     } catch (std::exception& e) {
42107       {
42108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42109       };
42110     } catch (Dali::DaliException e) {
42111       {
42112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42113       };
42114     } catch (...) {
42115       {
42116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42117       };
42118     }
42119   }
42120
42121   jresult = (void *)result;
42122   return jresult;
42123 }
42124
42125
42126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_2(void * jarg1) {
42127   void * jresult ;
42128   Dali::AlphaFunctionPrototype arg1 = (Dali::AlphaFunctionPrototype) 0 ;
42129   Dali::AlphaFunction *result = 0 ;
42130
42131   arg1 = (Dali::AlphaFunctionPrototype)jarg1;
42132   {
42133     try {
42134       result = (Dali::AlphaFunction *)new Dali::AlphaFunction(arg1);
42135     } catch (std::out_of_range& e) {
42136       {
42137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42138       };
42139     } catch (std::exception& e) {
42140       {
42141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42142       };
42143     } catch (Dali::DaliException e) {
42144       {
42145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42146       };
42147     } catch (...) {
42148       {
42149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42150       };
42151     }
42152   }
42153
42154   jresult = (void *)result;
42155   return jresult;
42156 }
42157
42158
42159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AlphaFunction__SWIG_3(void * jarg1, void * jarg2) {
42160   void * jresult ;
42161   Dali::Vector2 *arg1 = 0 ;
42162   Dali::Vector2 *arg2 = 0 ;
42163   Dali::AlphaFunction *result = 0 ;
42164
42165   arg1 = (Dali::Vector2 *)jarg1;
42166   if (!arg1) {
42167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42168     return 0;
42169   }
42170   arg2 = (Dali::Vector2 *)jarg2;
42171   if (!arg2) {
42172     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
42173     return 0;
42174   }
42175   {
42176     try {
42177       result = (Dali::AlphaFunction *)new Dali::AlphaFunction((Dali::Vector2 const &)*arg1,(Dali::Vector2 const &)*arg2);
42178     } catch (std::out_of_range& e) {
42179       {
42180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42181       };
42182     } catch (std::exception& e) {
42183       {
42184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42185       };
42186     } catch (Dali::DaliException e) {
42187       {
42188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42189       };
42190     } catch (...) {
42191       {
42192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42193       };
42194     }
42195   }
42196
42197   jresult = (void *)result;
42198   return jresult;
42199 }
42200
42201
42202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBezierControlPoints(void * jarg1) {
42203   void * jresult ;
42204   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42205   Dali::Vector4 result;
42206
42207   arg1 = (Dali::AlphaFunction *)jarg1;
42208   {
42209     try {
42210       result = ((Dali::AlphaFunction const *)arg1)->GetBezierControlPoints();
42211     } catch (std::out_of_range& e) {
42212       {
42213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42214       };
42215     } catch (std::exception& e) {
42216       {
42217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42218       };
42219     } catch (Dali::DaliException e) {
42220       {
42221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42222       };
42223     } catch (...) {
42224       {
42225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42226       };
42227     }
42228   }
42229
42230   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
42231   return jresult;
42232 }
42233
42234
42235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AlphaFunction_GetCustomFunction(void * jarg1) {
42236   void * jresult ;
42237   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42238   Dali::AlphaFunctionPrototype result;
42239
42240   arg1 = (Dali::AlphaFunction *)jarg1;
42241   {
42242     try {
42243       result = (Dali::AlphaFunctionPrototype)((Dali::AlphaFunction const *)arg1)->GetCustomFunction();
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 = (void *)result;
42264   return jresult;
42265 }
42266
42267
42268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetBuiltinFunction(void * jarg1) {
42269   int jresult ;
42270   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42271   Dali::AlphaFunction::BuiltinFunction result;
42272
42273   arg1 = (Dali::AlphaFunction *)jarg1;
42274   {
42275     try {
42276       result = (Dali::AlphaFunction::BuiltinFunction)((Dali::AlphaFunction const *)arg1)->GetBuiltinFunction();
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 = (int)result;
42297   return jresult;
42298 }
42299
42300
42301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_AlphaFunction_GetMode(void * jarg1) {
42302   int jresult ;
42303   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42304   Dali::AlphaFunction::Mode result;
42305
42306   arg1 = (Dali::AlphaFunction *)jarg1;
42307   {
42308     try {
42309       result = (Dali::AlphaFunction::Mode)((Dali::AlphaFunction const *)arg1)->GetMode();
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 = (int)result;
42330   return jresult;
42331 }
42332
42333
42334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AlphaFunction(void * jarg1) {
42335   Dali::AlphaFunction *arg1 = (Dali::AlphaFunction *) 0 ;
42336
42337   arg1 = (Dali::AlphaFunction *)jarg1;
42338   {
42339     try {
42340       delete arg1;
42341     } catch (std::out_of_range& e) {
42342       {
42343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42344       };
42345     } catch (std::exception& e) {
42346       {
42347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42348       };
42349     } catch (Dali::DaliException e) {
42350       {
42351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42352       };
42353     } catch (...) {
42354       {
42355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42356       };
42357     }
42358   }
42359
42360 }
42361
42362
42363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_New() {
42364   void * jresult ;
42365   Dali::KeyFrames result;
42366
42367   {
42368     try {
42369       result = Dali::KeyFrames::New();
42370     } catch (std::out_of_range& e) {
42371       {
42372         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42373       };
42374     } catch (std::exception& e) {
42375       {
42376         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42377       };
42378     } catch (Dali::DaliException e) {
42379       {
42380         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42381       };
42382     } catch (...) {
42383       {
42384         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42385       };
42386     }
42387   }
42388
42389   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42390   return jresult;
42391 }
42392
42393
42394 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_DownCast(void * jarg1) {
42395   void * jresult ;
42396   Dali::BaseHandle arg1 ;
42397   Dali::BaseHandle *argp1 ;
42398   Dali::KeyFrames result;
42399
42400   argp1 = (Dali::BaseHandle *)jarg1;
42401   if (!argp1) {
42402     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42403     return 0;
42404   }
42405   arg1 = *argp1;
42406   {
42407     try {
42408       result = Dali::KeyFrames::DownCast(arg1);
42409     } catch (std::out_of_range& e) {
42410       {
42411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42412       };
42413     } catch (std::exception& e) {
42414       {
42415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42416       };
42417     } catch (Dali::DaliException e) {
42418       {
42419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42420       };
42421     } catch (...) {
42422       {
42423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42424       };
42425     }
42426   }
42427
42428   jresult = new Dali::KeyFrames((const Dali::KeyFrames &)result);
42429   return jresult;
42430 }
42431
42432
42433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_0() {
42434   void * jresult ;
42435   Dali::KeyFrames *result = 0 ;
42436
42437   {
42438     try {
42439       result = (Dali::KeyFrames *)new Dali::KeyFrames();
42440     } catch (std::out_of_range& e) {
42441       {
42442         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42443       };
42444     } catch (std::exception& e) {
42445       {
42446         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42447       };
42448     } catch (Dali::DaliException e) {
42449       {
42450         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42451       };
42452     } catch (...) {
42453       {
42454         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42455       };
42456     }
42457   }
42458
42459   jresult = (void *)result;
42460   return jresult;
42461 }
42462
42463
42464 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyFrames(void * jarg1) {
42465   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42466
42467   arg1 = (Dali::KeyFrames *)jarg1;
42468   {
42469     try {
42470       delete arg1;
42471     } catch (std::out_of_range& e) {
42472       {
42473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42474       };
42475     } catch (std::exception& e) {
42476       {
42477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42478       };
42479     } catch (Dali::DaliException e) {
42480       {
42481         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42482       };
42483     } catch (...) {
42484       {
42485         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42486       };
42487     }
42488   }
42489
42490 }
42491
42492
42493 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyFrames__SWIG_1(void * jarg1) {
42494   void * jresult ;
42495   Dali::KeyFrames *arg1 = 0 ;
42496   Dali::KeyFrames *result = 0 ;
42497
42498   arg1 = (Dali::KeyFrames *)jarg1;
42499   if (!arg1) {
42500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42501     return 0;
42502   }
42503   {
42504     try {
42505       result = (Dali::KeyFrames *)new Dali::KeyFrames((Dali::KeyFrames const &)*arg1);
42506     } catch (std::out_of_range& e) {
42507       {
42508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42509       };
42510     } catch (std::exception& e) {
42511       {
42512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42513       };
42514     } catch (Dali::DaliException e) {
42515       {
42516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42517       };
42518     } catch (...) {
42519       {
42520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42521       };
42522     }
42523   }
42524
42525   jresult = (void *)result;
42526   return jresult;
42527 }
42528
42529
42530 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyFrames_Assign(void * jarg1, void * jarg2) {
42531   void * jresult ;
42532   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42533   Dali::KeyFrames *arg2 = 0 ;
42534   Dali::KeyFrames *result = 0 ;
42535
42536   arg1 = (Dali::KeyFrames *)jarg1;
42537   arg2 = (Dali::KeyFrames *)jarg2;
42538   if (!arg2) {
42539     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyFrames const & type is null", 0);
42540     return 0;
42541   }
42542   {
42543     try {
42544       result = (Dali::KeyFrames *) &(arg1)->operator =((Dali::KeyFrames const &)*arg2);
42545     } catch (std::out_of_range& e) {
42546       {
42547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42548       };
42549     } catch (std::exception& e) {
42550       {
42551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42552       };
42553     } catch (Dali::DaliException e) {
42554       {
42555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42556       };
42557     } catch (...) {
42558       {
42559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42560       };
42561     }
42562   }
42563
42564   jresult = (void *)result;
42565   return jresult;
42566 }
42567
42568
42569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_KeyFrames_GetType(void * jarg1) {
42570   int jresult ;
42571   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42572   Dali::Property::Type result;
42573
42574   arg1 = (Dali::KeyFrames *)jarg1;
42575   {
42576     try {
42577       result = (Dali::Property::Type)((Dali::KeyFrames const *)arg1)->GetType();
42578     } catch (std::out_of_range& e) {
42579       {
42580         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42581       };
42582     } catch (std::exception& e) {
42583       {
42584         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42585       };
42586     } catch (Dali::DaliException e) {
42587       {
42588         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42589       };
42590     } catch (...) {
42591       {
42592         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42593       };
42594     }
42595   }
42596
42597   jresult = (int)result;
42598   return jresult;
42599 }
42600
42601
42602 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_0(void * jarg1, float jarg2, void * jarg3) {
42603   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42604   float arg2 ;
42605   Dali::Property::Value arg3 ;
42606   Dali::Property::Value *argp3 ;
42607
42608   arg1 = (Dali::KeyFrames *)jarg1;
42609   arg2 = (float)jarg2;
42610   argp3 = (Dali::Property::Value *)jarg3;
42611   if (!argp3) {
42612     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42613     return ;
42614   }
42615   arg3 = *argp3;
42616   {
42617     try {
42618       (arg1)->Add(arg2,arg3);
42619     } catch (std::out_of_range& e) {
42620       {
42621         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42622       };
42623     } catch (std::exception& e) {
42624       {
42625         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42626       };
42627     } catch (Dali::DaliException e) {
42628       {
42629         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42630       };
42631     } catch (...) {
42632       {
42633         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42634       };
42635     }
42636   }
42637
42638 }
42639
42640
42641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyFrames_Add__SWIG_1(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
42642   Dali::KeyFrames *arg1 = (Dali::KeyFrames *) 0 ;
42643   float arg2 ;
42644   Dali::Property::Value arg3 ;
42645   Dali::AlphaFunction arg4 ;
42646   Dali::Property::Value *argp3 ;
42647   Dali::AlphaFunction *argp4 ;
42648
42649   arg1 = (Dali::KeyFrames *)jarg1;
42650   arg2 = (float)jarg2;
42651   argp3 = (Dali::Property::Value *)jarg3;
42652   if (!argp3) {
42653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
42654     return ;
42655   }
42656   arg3 = *argp3;
42657   argp4 = (Dali::AlphaFunction *)jarg4;
42658   if (!argp4) {
42659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
42660     return ;
42661   }
42662   arg4 = *argp4;
42663   {
42664     try {
42665       (arg1)->Add(arg2,arg3,arg4);
42666     } catch (std::out_of_range& e) {
42667       {
42668         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42669       };
42670     } catch (std::exception& e) {
42671       {
42672         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42673       };
42674     } catch (Dali::DaliException e) {
42675       {
42676         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42677       };
42678     } catch (...) {
42679       {
42680         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42681       };
42682     }
42683   }
42684
42685 }
42686
42687
42688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_POINTS_get() {
42689   int jresult ;
42690   int result;
42691
42692   result = (int)Dali::Path::Property::POINTS;
42693   jresult = (int)result;
42694   return jresult;
42695 }
42696
42697
42698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Path_Property_CONTROL_POINTS_get() {
42699   int jresult ;
42700   int result;
42701
42702   result = (int)Dali::Path::Property::CONTROL_POINTS;
42703   jresult = (int)result;
42704   return jresult;
42705 }
42706
42707
42708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path_Property() {
42709   void * jresult ;
42710   Dali::Path::Property *result = 0 ;
42711
42712   {
42713     try {
42714       result = (Dali::Path::Property *)new Dali::Path::Property();
42715     } catch (std::out_of_range& e) {
42716       {
42717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42718       };
42719     } catch (std::exception& e) {
42720       {
42721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42722       };
42723     } catch (Dali::DaliException e) {
42724       {
42725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42726       };
42727     } catch (...) {
42728       {
42729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42730       };
42731     }
42732   }
42733
42734   jresult = (void *)result;
42735   return jresult;
42736 }
42737
42738
42739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path_Property(void * jarg1) {
42740   Dali::Path::Property *arg1 = (Dali::Path::Property *) 0 ;
42741
42742   arg1 = (Dali::Path::Property *)jarg1;
42743   {
42744     try {
42745       delete arg1;
42746     } catch (std::out_of_range& e) {
42747       {
42748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42749       };
42750     } catch (std::exception& e) {
42751       {
42752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42753       };
42754     } catch (Dali::DaliException e) {
42755       {
42756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42757       };
42758     } catch (...) {
42759       {
42760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42761       };
42762     }
42763   }
42764
42765 }
42766
42767
42768 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_New() {
42769   void * jresult ;
42770   Dali::Path result;
42771
42772   {
42773     try {
42774       result = Dali::Path::New();
42775     } catch (std::out_of_range& e) {
42776       {
42777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42778       };
42779     } catch (std::exception& e) {
42780       {
42781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42782       };
42783     } catch (Dali::DaliException e) {
42784       {
42785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42786       };
42787     } catch (...) {
42788       {
42789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42790       };
42791     }
42792   }
42793
42794   jresult = new Dali::Path((const Dali::Path &)result);
42795   return jresult;
42796 }
42797
42798
42799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_DownCast(void * jarg1) {
42800   void * jresult ;
42801   Dali::BaseHandle arg1 ;
42802   Dali::BaseHandle *argp1 ;
42803   Dali::Path result;
42804
42805   argp1 = (Dali::BaseHandle *)jarg1;
42806   if (!argp1) {
42807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
42808     return 0;
42809   }
42810   arg1 = *argp1;
42811   {
42812     try {
42813       result = Dali::Path::DownCast(arg1);
42814     } catch (std::out_of_range& e) {
42815       {
42816         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42817       };
42818     } catch (std::exception& e) {
42819       {
42820         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42821       };
42822     } catch (Dali::DaliException e) {
42823       {
42824         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42825       };
42826     } catch (...) {
42827       {
42828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42829       };
42830     }
42831   }
42832
42833   jresult = new Dali::Path((const Dali::Path &)result);
42834   return jresult;
42835 }
42836
42837
42838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_0() {
42839   void * jresult ;
42840   Dali::Path *result = 0 ;
42841
42842   {
42843     try {
42844       result = (Dali::Path *)new Dali::Path();
42845     } catch (std::out_of_range& e) {
42846       {
42847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42848       };
42849     } catch (std::exception& e) {
42850       {
42851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42852       };
42853     } catch (Dali::DaliException e) {
42854       {
42855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42856       };
42857     } catch (...) {
42858       {
42859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42860       };
42861     }
42862   }
42863
42864   jresult = (void *)result;
42865   return jresult;
42866 }
42867
42868
42869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Path(void * jarg1) {
42870   Dali::Path *arg1 = (Dali::Path *) 0 ;
42871
42872   arg1 = (Dali::Path *)jarg1;
42873   {
42874     try {
42875       delete arg1;
42876     } catch (std::out_of_range& e) {
42877       {
42878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42879       };
42880     } catch (std::exception& e) {
42881       {
42882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42883       };
42884     } catch (Dali::DaliException e) {
42885       {
42886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42887       };
42888     } catch (...) {
42889       {
42890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
42891       };
42892     }
42893   }
42894
42895 }
42896
42897
42898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Path__SWIG_1(void * jarg1) {
42899   void * jresult ;
42900   Dali::Path *arg1 = 0 ;
42901   Dali::Path *result = 0 ;
42902
42903   arg1 = (Dali::Path *)jarg1;
42904   if (!arg1) {
42905     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42906     return 0;
42907   }
42908   {
42909     try {
42910       result = (Dali::Path *)new Dali::Path((Dali::Path const &)*arg1);
42911     } catch (std::out_of_range& e) {
42912       {
42913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42914       };
42915     } catch (std::exception& e) {
42916       {
42917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42918       };
42919     } catch (Dali::DaliException e) {
42920       {
42921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42922       };
42923     } catch (...) {
42924       {
42925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42926       };
42927     }
42928   }
42929
42930   jresult = (void *)result;
42931   return jresult;
42932 }
42933
42934
42935 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_Assign(void * jarg1, void * jarg2) {
42936   void * jresult ;
42937   Dali::Path *arg1 = (Dali::Path *) 0 ;
42938   Dali::Path *arg2 = 0 ;
42939   Dali::Path *result = 0 ;
42940
42941   arg1 = (Dali::Path *)jarg1;
42942   arg2 = (Dali::Path *)jarg2;
42943   if (!arg2) {
42944     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Path const & type is null", 0);
42945     return 0;
42946   }
42947   {
42948     try {
42949       result = (Dali::Path *) &(arg1)->operator =((Dali::Path const &)*arg2);
42950     } catch (std::out_of_range& e) {
42951       {
42952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
42953       };
42954     } catch (std::exception& e) {
42955       {
42956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
42957       };
42958     } catch (Dali::DaliException e) {
42959       {
42960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
42961       };
42962     } catch (...) {
42963       {
42964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
42965       };
42966     }
42967   }
42968
42969   jresult = (void *)result;
42970   return jresult;
42971 }
42972
42973
42974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddPoint(void * jarg1, void * jarg2) {
42975   Dali::Path *arg1 = (Dali::Path *) 0 ;
42976   Dali::Vector3 *arg2 = 0 ;
42977
42978   arg1 = (Dali::Path *)jarg1;
42979   arg2 = (Dali::Vector3 *)jarg2;
42980   if (!arg2) {
42981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
42982     return ;
42983   }
42984   {
42985     try {
42986       (arg1)->AddPoint((Dali::Vector3 const &)*arg2);
42987     } catch (std::out_of_range& e) {
42988       {
42989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
42990       };
42991     } catch (std::exception& e) {
42992       {
42993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
42994       };
42995     } catch (Dali::DaliException e) {
42996       {
42997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
42998       };
42999     } catch (...) {
43000       {
43001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43002       };
43003     }
43004   }
43005
43006 }
43007
43008
43009 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_AddControlPoint(void * jarg1, void * jarg2) {
43010   Dali::Path *arg1 = (Dali::Path *) 0 ;
43011   Dali::Vector3 *arg2 = 0 ;
43012
43013   arg1 = (Dali::Path *)jarg1;
43014   arg2 = (Dali::Vector3 *)jarg2;
43015   if (!arg2) {
43016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
43017     return ;
43018   }
43019   {
43020     try {
43021       (arg1)->AddControlPoint((Dali::Vector3 const &)*arg2);
43022     } catch (std::out_of_range& e) {
43023       {
43024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43025       };
43026     } catch (std::exception& e) {
43027       {
43028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43029       };
43030     } catch (Dali::DaliException e) {
43031       {
43032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43033       };
43034     } catch (...) {
43035       {
43036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43037       };
43038     }
43039   }
43040
43041 }
43042
43043
43044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_GenerateControlPoints(void * jarg1, float jarg2) {
43045   Dali::Path *arg1 = (Dali::Path *) 0 ;
43046   float arg2 ;
43047
43048   arg1 = (Dali::Path *)jarg1;
43049   arg2 = (float)jarg2;
43050   {
43051     try {
43052       (arg1)->GenerateControlPoints(arg2);
43053     } catch (std::out_of_range& e) {
43054       {
43055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43056       };
43057     } catch (std::exception& e) {
43058       {
43059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43060       };
43061     } catch (Dali::DaliException e) {
43062       {
43063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43064       };
43065     } catch (...) {
43066       {
43067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43068       };
43069     }
43070   }
43071
43072 }
43073
43074
43075 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Path_Sample(void * jarg1, float jarg2, void * jarg3, void * jarg4) {
43076   Dali::Path *arg1 = (Dali::Path *) 0 ;
43077   float arg2 ;
43078   Dali::Vector3 *arg3 = 0 ;
43079   Dali::Vector3 *arg4 = 0 ;
43080
43081   arg1 = (Dali::Path *)jarg1;
43082   arg2 = (float)jarg2;
43083   arg3 = (Dali::Vector3 *)jarg3;
43084   if (!arg3) {
43085     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43086     return ;
43087   }
43088   arg4 = (Dali::Vector3 *)jarg4;
43089   if (!arg4) {
43090     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
43091     return ;
43092   }
43093   {
43094     try {
43095       ((Dali::Path const *)arg1)->Sample(arg2,*arg3,*arg4);
43096     } catch (std::out_of_range& e) {
43097       {
43098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43099       };
43100     } catch (std::exception& e) {
43101       {
43102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43103       };
43104     } catch (Dali::DaliException e) {
43105       {
43106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43107       };
43108     } catch (...) {
43109       {
43110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43111       };
43112     }
43113   }
43114
43115 }
43116
43117
43118 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetPoint(void * jarg1, unsigned long jarg2) {
43119   void * jresult ;
43120   Dali::Path *arg1 = (Dali::Path *) 0 ;
43121   size_t arg2 ;
43122   Dali::Vector3 *result = 0 ;
43123
43124   arg1 = (Dali::Path *)jarg1;
43125   arg2 = (size_t)jarg2;
43126   {
43127     try {
43128       result = (Dali::Vector3 *) &(arg1)->GetPoint(arg2);
43129     } catch (std::out_of_range& e) {
43130       {
43131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43132       };
43133     } catch (std::exception& e) {
43134       {
43135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43136       };
43137     } catch (Dali::DaliException e) {
43138       {
43139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43140       };
43141     } catch (...) {
43142       {
43143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43144       };
43145     }
43146   }
43147
43148   jresult = (void *)result;
43149   return jresult;
43150 }
43151
43152
43153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Path_GetControlPoint(void * jarg1, unsigned long jarg2) {
43154   void * jresult ;
43155   Dali::Path *arg1 = (Dali::Path *) 0 ;
43156   size_t arg2 ;
43157   Dali::Vector3 *result = 0 ;
43158
43159   arg1 = (Dali::Path *)jarg1;
43160   arg2 = (size_t)jarg2;
43161   {
43162     try {
43163       result = (Dali::Vector3 *) &(arg1)->GetControlPoint(arg2);
43164     } catch (std::out_of_range& e) {
43165       {
43166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43167       };
43168     } catch (std::exception& e) {
43169       {
43170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43171       };
43172     } catch (Dali::DaliException e) {
43173       {
43174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43175       };
43176     } catch (...) {
43177       {
43178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43179       };
43180     }
43181   }
43182
43183   jresult = (void *)result;
43184   return jresult;
43185 }
43186
43187
43188 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_Path_GetPointCount(void * jarg1) {
43189   unsigned long jresult ;
43190   Dali::Path *arg1 = (Dali::Path *) 0 ;
43191   size_t result;
43192
43193   arg1 = (Dali::Path *)jarg1;
43194   {
43195     try {
43196       result = ((Dali::Path const *)arg1)->GetPointCount();
43197     } catch (std::out_of_range& e) {
43198       {
43199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43200       };
43201     } catch (std::exception& e) {
43202       {
43203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43204       };
43205     } catch (Dali::DaliException e) {
43206       {
43207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43208       };
43209     } catch (...) {
43210       {
43211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43212       };
43213     }
43214   }
43215
43216   jresult = (unsigned long)result;
43217   return jresult;
43218 }
43219
43220
43221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_0(float jarg1) {
43222   void * jresult ;
43223   float arg1 ;
43224   Dali::TimePeriod *result = 0 ;
43225
43226   arg1 = (float)jarg1;
43227   {
43228     try {
43229       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1);
43230     } catch (std::out_of_range& e) {
43231       {
43232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43233       };
43234     } catch (std::exception& e) {
43235       {
43236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43237       };
43238     } catch (Dali::DaliException e) {
43239       {
43240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43241       };
43242     } catch (...) {
43243       {
43244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43245       };
43246     }
43247   }
43248
43249   jresult = (void *)result;
43250   return jresult;
43251 }
43252
43253
43254 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimePeriod__SWIG_1(float jarg1, float jarg2) {
43255   void * jresult ;
43256   float arg1 ;
43257   float arg2 ;
43258   Dali::TimePeriod *result = 0 ;
43259
43260   arg1 = (float)jarg1;
43261   arg2 = (float)jarg2;
43262   {
43263     try {
43264       result = (Dali::TimePeriod *)new Dali::TimePeriod(arg1,arg2);
43265     } catch (std::out_of_range& e) {
43266       {
43267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43268       };
43269     } catch (std::exception& e) {
43270       {
43271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43272       };
43273     } catch (Dali::DaliException e) {
43274       {
43275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43276       };
43277     } catch (...) {
43278       {
43279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43280       };
43281     }
43282   }
43283
43284   jresult = (void *)result;
43285   return jresult;
43286 }
43287
43288
43289 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimePeriod(void * jarg1) {
43290   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43291
43292   arg1 = (Dali::TimePeriod *)jarg1;
43293   {
43294     try {
43295       delete arg1;
43296     } catch (std::out_of_range& e) {
43297       {
43298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43299       };
43300     } catch (std::exception& e) {
43301       {
43302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43303       };
43304     } catch (Dali::DaliException e) {
43305       {
43306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43307       };
43308     } catch (...) {
43309       {
43310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43311       };
43312     }
43313   }
43314
43315 }
43316
43317
43318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_set(void * jarg1, float jarg2) {
43319   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43320   float arg2 ;
43321
43322   arg1 = (Dali::TimePeriod *)jarg1;
43323   arg2 = (float)jarg2;
43324   if (arg1) (arg1)->delaySeconds = arg2;
43325 }
43326
43327
43328 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_delaySeconds_get(void * jarg1) {
43329   float jresult ;
43330   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43331   float result;
43332
43333   arg1 = (Dali::TimePeriod *)jarg1;
43334   result = (float) ((arg1)->delaySeconds);
43335   jresult = result;
43336   return jresult;
43337 }
43338
43339
43340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_set(void * jarg1, float jarg2) {
43341   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43342   float arg2 ;
43343
43344   arg1 = (Dali::TimePeriod *)jarg1;
43345   arg2 = (float)jarg2;
43346   if (arg1) (arg1)->durationSeconds = arg2;
43347 }
43348
43349
43350 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TimePeriod_durationSeconds_get(void * jarg1) {
43351   float jresult ;
43352   Dali::TimePeriod *arg1 = (Dali::TimePeriod *) 0 ;
43353   float result;
43354
43355   arg1 = (Dali::TimePeriod *)jarg1;
43356   result = (float) ((arg1)->durationSeconds);
43357   jresult = result;
43358   return jresult;
43359 }
43360
43361 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_VALUE_get() {
43362   int jresult ;
43363   int result;
43364
43365   result = (int)Dali::LinearConstrainer::Property::VALUE;
43366   jresult = (int)result;
43367   return jresult;
43368 }
43369
43370
43371 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_LinearConstrainer_Property_PROGRESS_get() {
43372   int jresult ;
43373   int result;
43374
43375   result = (int)Dali::LinearConstrainer::Property::PROGRESS;
43376   jresult = (int)result;
43377   return jresult;
43378 }
43379
43380
43381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer_Property() {
43382   void * jresult ;
43383   Dali::LinearConstrainer::Property *result = 0 ;
43384
43385   {
43386     try {
43387       result = (Dali::LinearConstrainer::Property *)new Dali::LinearConstrainer::Property();
43388     } catch (std::out_of_range& e) {
43389       {
43390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43391       };
43392     } catch (std::exception& e) {
43393       {
43394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43395       };
43396     } catch (Dali::DaliException e) {
43397       {
43398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43399       };
43400     } catch (...) {
43401       {
43402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43403       };
43404     }
43405   }
43406
43407   jresult = (void *)result;
43408   return jresult;
43409 }
43410
43411
43412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer_Property(void * jarg1) {
43413   Dali::LinearConstrainer::Property *arg1 = (Dali::LinearConstrainer::Property *) 0 ;
43414
43415   arg1 = (Dali::LinearConstrainer::Property *)jarg1;
43416   {
43417     try {
43418       delete arg1;
43419     } catch (std::out_of_range& e) {
43420       {
43421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43422       };
43423     } catch (std::exception& e) {
43424       {
43425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43426       };
43427     } catch (Dali::DaliException e) {
43428       {
43429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43430       };
43431     } catch (...) {
43432       {
43433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43434       };
43435     }
43436   }
43437
43438 }
43439
43440
43441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_New() {
43442   void * jresult ;
43443   Dali::LinearConstrainer result;
43444
43445   {
43446     try {
43447       result = Dali::LinearConstrainer::New();
43448     } catch (std::out_of_range& e) {
43449       {
43450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43451       };
43452     } catch (std::exception& e) {
43453       {
43454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43455       };
43456     } catch (Dali::DaliException e) {
43457       {
43458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43459       };
43460     } catch (...) {
43461       {
43462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43463       };
43464     }
43465   }
43466
43467   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43468   return jresult;
43469 }
43470
43471
43472 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_DownCast(void * jarg1) {
43473   void * jresult ;
43474   Dali::BaseHandle arg1 ;
43475   Dali::BaseHandle *argp1 ;
43476   Dali::LinearConstrainer result;
43477
43478   argp1 = (Dali::BaseHandle *)jarg1;
43479   if (!argp1) {
43480     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43481     return 0;
43482   }
43483   arg1 = *argp1;
43484   {
43485     try {
43486       result = Dali::LinearConstrainer::DownCast(arg1);
43487     } catch (std::out_of_range& e) {
43488       {
43489         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43490       };
43491     } catch (std::exception& e) {
43492       {
43493         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43494       };
43495     } catch (Dali::DaliException e) {
43496       {
43497         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43498       };
43499     } catch (...) {
43500       {
43501         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43502       };
43503     }
43504   }
43505
43506   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
43507   return jresult;
43508 }
43509
43510
43511 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LinearConstrainer__SWIG_0() {
43512   void * jresult ;
43513   Dali::LinearConstrainer *result = 0 ;
43514
43515   {
43516     try {
43517       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer();
43518     } catch (std::out_of_range& e) {
43519       {
43520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43521       };
43522     } catch (std::exception& e) {
43523       {
43524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43525       };
43526     } catch (Dali::DaliException e) {
43527       {
43528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43529       };
43530     } catch (...) {
43531       {
43532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43533       };
43534     }
43535   }
43536
43537   jresult = (void *)result;
43538   return jresult;
43539 }
43540
43541
43542 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LinearConstrainer(void * jarg1) {
43543   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43544
43545   arg1 = (Dali::LinearConstrainer *)jarg1;
43546   {
43547     try {
43548       delete arg1;
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_new_LinearConstrainer__SWIG_1(void * jarg1) {
43572   void * jresult ;
43573   Dali::LinearConstrainer *arg1 = 0 ;
43574   Dali::LinearConstrainer *result = 0 ;
43575
43576   arg1 = (Dali::LinearConstrainer *)jarg1;
43577   if (!arg1) {
43578     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43579     return 0;
43580   }
43581   {
43582     try {
43583       result = (Dali::LinearConstrainer *)new Dali::LinearConstrainer((Dali::LinearConstrainer const &)*arg1);
43584     } catch (std::out_of_range& e) {
43585       {
43586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43587       };
43588     } catch (std::exception& e) {
43589       {
43590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43591       };
43592     } catch (Dali::DaliException e) {
43593       {
43594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43595       };
43596     } catch (...) {
43597       {
43598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43599       };
43600     }
43601   }
43602
43603   jresult = (void *)result;
43604   return jresult;
43605 }
43606
43607
43608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LinearConstrainer_Assign(void * jarg1, void * jarg2) {
43609   void * jresult ;
43610   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43611   Dali::LinearConstrainer *arg2 = 0 ;
43612   Dali::LinearConstrainer *result = 0 ;
43613
43614   arg1 = (Dali::LinearConstrainer *)jarg1;
43615   arg2 = (Dali::LinearConstrainer *)jarg2;
43616   if (!arg2) {
43617     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LinearConstrainer const & type is null", 0);
43618     return 0;
43619   }
43620   {
43621     try {
43622       result = (Dali::LinearConstrainer *) &(arg1)->operator =((Dali::LinearConstrainer const &)*arg2);
43623     } catch (std::out_of_range& e) {
43624       {
43625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43626       };
43627     } catch (std::exception& e) {
43628       {
43629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43630       };
43631     } catch (Dali::DaliException e) {
43632       {
43633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43634       };
43635     } catch (...) {
43636       {
43637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43638       };
43639     }
43640   }
43641
43642   jresult = (void *)result;
43643   return jresult;
43644 }
43645
43646
43647 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
43648   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43649   SwigValueWrapper< Dali::Property > arg2 ;
43650   SwigValueWrapper< Dali::Property > arg3 ;
43651   Dali::Vector2 *arg4 = 0 ;
43652   Dali::Vector2 *arg5 = 0 ;
43653   Dali::Property *argp2 ;
43654   Dali::Property *argp3 ;
43655
43656   arg1 = (Dali::LinearConstrainer *)jarg1;
43657   argp2 = (Dali::Property *)jarg2;
43658   if (!argp2) {
43659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43660     return ;
43661   }
43662   arg2 = *argp2;
43663   argp3 = (Dali::Property *)jarg3;
43664   if (!argp3) {
43665     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43666     return ;
43667   }
43668   arg3 = *argp3;
43669   arg4 = (Dali::Vector2 *)jarg4;
43670   if (!arg4) {
43671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43672     return ;
43673   }
43674   arg5 = (Dali::Vector2 *)jarg5;
43675   if (!arg5) {
43676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43677     return ;
43678   }
43679   {
43680     try {
43681       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
43682     } catch (std::out_of_range& e) {
43683       {
43684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43685       };
43686     } catch (std::exception& e) {
43687       {
43688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43689       };
43690     } catch (Dali::DaliException e) {
43691       {
43692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43693       };
43694     } catch (...) {
43695       {
43696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43697       };
43698     }
43699   }
43700
43701 }
43702
43703
43704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
43705   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43706   SwigValueWrapper< Dali::Property > arg2 ;
43707   SwigValueWrapper< Dali::Property > arg3 ;
43708   Dali::Vector2 *arg4 = 0 ;
43709   Dali::Property *argp2 ;
43710   Dali::Property *argp3 ;
43711
43712   arg1 = (Dali::LinearConstrainer *)jarg1;
43713   argp2 = (Dali::Property *)jarg2;
43714   if (!argp2) {
43715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43716     return ;
43717   }
43718   arg2 = *argp2;
43719   argp3 = (Dali::Property *)jarg3;
43720   if (!argp3) {
43721     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
43722     return ;
43723   }
43724   arg3 = *argp3;
43725   arg4 = (Dali::Vector2 *)jarg4;
43726   if (!arg4) {
43727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
43728     return ;
43729   }
43730   {
43731     try {
43732       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
43733     } catch (std::out_of_range& e) {
43734       {
43735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43736       };
43737     } catch (std::exception& e) {
43738       {
43739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43740       };
43741     } catch (Dali::DaliException e) {
43742       {
43743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43744       };
43745     } catch (...) {
43746       {
43747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43748       };
43749     }
43750   }
43751
43752 }
43753
43754
43755 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LinearConstrainer_Remove(void * jarg1, void * jarg2) {
43756   Dali::LinearConstrainer *arg1 = (Dali::LinearConstrainer *) 0 ;
43757   Dali::Handle *arg2 = 0 ;
43758
43759   arg1 = (Dali::LinearConstrainer *)jarg1;
43760   arg2 = (Dali::Handle *)jarg2;
43761   if (!arg2) {
43762     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
43763     return ;
43764   }
43765   {
43766     try {
43767       (arg1)->Remove(*arg2);
43768     } catch (std::out_of_range& e) {
43769       {
43770         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43771       };
43772     } catch (std::exception& e) {
43773       {
43774         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43775       };
43776     } catch (Dali::DaliException e) {
43777       {
43778         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43779       };
43780     } catch (...) {
43781       {
43782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43783       };
43784     }
43785   }
43786
43787 }
43788
43789
43790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_FORWARD_get() {
43791   int jresult ;
43792   int result;
43793
43794   result = (int)Dali::PathConstrainer::Property::FORWARD;
43795   jresult = (int)result;
43796   return jresult;
43797 }
43798
43799
43800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_POINTS_get() {
43801   int jresult ;
43802   int result;
43803
43804   result = (int)Dali::PathConstrainer::Property::POINTS;
43805   jresult = (int)result;
43806   return jresult;
43807 }
43808
43809
43810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PathConstrainer_Property_CONTROL_POINTS_get() {
43811   int jresult ;
43812   int result;
43813
43814   result = (int)Dali::PathConstrainer::Property::CONTROL_POINTS;
43815   jresult = (int)result;
43816   return jresult;
43817 }
43818
43819
43820 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer_Property() {
43821   void * jresult ;
43822   Dali::PathConstrainer::Property *result = 0 ;
43823
43824   {
43825     try {
43826       result = (Dali::PathConstrainer::Property *)new Dali::PathConstrainer::Property();
43827     } catch (std::out_of_range& e) {
43828       {
43829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43830       };
43831     } catch (std::exception& e) {
43832       {
43833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43834       };
43835     } catch (Dali::DaliException e) {
43836       {
43837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43838       };
43839     } catch (...) {
43840       {
43841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43842       };
43843     }
43844   }
43845
43846   jresult = (void *)result;
43847   return jresult;
43848 }
43849
43850
43851 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer_Property(void * jarg1) {
43852   Dali::PathConstrainer::Property *arg1 = (Dali::PathConstrainer::Property *) 0 ;
43853
43854   arg1 = (Dali::PathConstrainer::Property *)jarg1;
43855   {
43856     try {
43857       delete arg1;
43858     } catch (std::out_of_range& e) {
43859       {
43860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43861       };
43862     } catch (std::exception& e) {
43863       {
43864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43865       };
43866     } catch (Dali::DaliException e) {
43867       {
43868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43869       };
43870     } catch (...) {
43871       {
43872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
43873       };
43874     }
43875   }
43876
43877 }
43878
43879
43880 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_New() {
43881   void * jresult ;
43882   Dali::PathConstrainer result;
43883
43884   {
43885     try {
43886       result = Dali::PathConstrainer::New();
43887     } catch (std::out_of_range& e) {
43888       {
43889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43890       };
43891     } catch (std::exception& e) {
43892       {
43893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43894       };
43895     } catch (Dali::DaliException e) {
43896       {
43897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43898       };
43899     } catch (...) {
43900       {
43901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43902       };
43903     }
43904   }
43905
43906   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43907   return jresult;
43908 }
43909
43910
43911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_DownCast(void * jarg1) {
43912   void * jresult ;
43913   Dali::BaseHandle arg1 ;
43914   Dali::BaseHandle *argp1 ;
43915   Dali::PathConstrainer result;
43916
43917   argp1 = (Dali::BaseHandle *)jarg1;
43918   if (!argp1) {
43919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
43920     return 0;
43921   }
43922   arg1 = *argp1;
43923   {
43924     try {
43925       result = Dali::PathConstrainer::DownCast(arg1);
43926     } catch (std::out_of_range& e) {
43927       {
43928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43929       };
43930     } catch (std::exception& e) {
43931       {
43932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43933       };
43934     } catch (Dali::DaliException e) {
43935       {
43936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43937       };
43938     } catch (...) {
43939       {
43940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43941       };
43942     }
43943   }
43944
43945   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
43946   return jresult;
43947 }
43948
43949
43950 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_0() {
43951   void * jresult ;
43952   Dali::PathConstrainer *result = 0 ;
43953
43954   {
43955     try {
43956       result = (Dali::PathConstrainer *)new Dali::PathConstrainer();
43957     } catch (std::out_of_range& e) {
43958       {
43959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
43960       };
43961     } catch (std::exception& e) {
43962       {
43963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
43964       };
43965     } catch (Dali::DaliException e) {
43966       {
43967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
43968       };
43969     } catch (...) {
43970       {
43971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
43972       };
43973     }
43974   }
43975
43976   jresult = (void *)result;
43977   return jresult;
43978 }
43979
43980
43981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PathConstrainer(void * jarg1) {
43982   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
43983
43984   arg1 = (Dali::PathConstrainer *)jarg1;
43985   {
43986     try {
43987       delete arg1;
43988     } catch (std::out_of_range& e) {
43989       {
43990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
43991       };
43992     } catch (std::exception& e) {
43993       {
43994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
43995       };
43996     } catch (Dali::DaliException e) {
43997       {
43998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
43999       };
44000     } catch (...) {
44001       {
44002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44003       };
44004     }
44005   }
44006
44007 }
44008
44009
44010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PathConstrainer__SWIG_1(void * jarg1) {
44011   void * jresult ;
44012   Dali::PathConstrainer *arg1 = 0 ;
44013   Dali::PathConstrainer *result = 0 ;
44014
44015   arg1 = (Dali::PathConstrainer *)jarg1;
44016   if (!arg1) {
44017     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44018     return 0;
44019   }
44020   {
44021     try {
44022       result = (Dali::PathConstrainer *)new Dali::PathConstrainer((Dali::PathConstrainer const &)*arg1);
44023     } catch (std::out_of_range& e) {
44024       {
44025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44026       };
44027     } catch (std::exception& e) {
44028       {
44029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44030       };
44031     } catch (Dali::DaliException e) {
44032       {
44033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44034       };
44035     } catch (...) {
44036       {
44037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44038       };
44039     }
44040   }
44041
44042   jresult = (void *)result;
44043   return jresult;
44044 }
44045
44046
44047 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PathConstrainer_Assign(void * jarg1, void * jarg2) {
44048   void * jresult ;
44049   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44050   Dali::PathConstrainer *arg2 = 0 ;
44051   Dali::PathConstrainer *result = 0 ;
44052
44053   arg1 = (Dali::PathConstrainer *)jarg1;
44054   arg2 = (Dali::PathConstrainer *)jarg2;
44055   if (!arg2) {
44056     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PathConstrainer const & type is null", 0);
44057     return 0;
44058   }
44059   {
44060     try {
44061       result = (Dali::PathConstrainer *) &(arg1)->operator =((Dali::PathConstrainer const &)*arg2);
44062     } catch (std::out_of_range& e) {
44063       {
44064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44065       };
44066     } catch (std::exception& e) {
44067       {
44068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44069       };
44070     } catch (Dali::DaliException e) {
44071       {
44072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44073       };
44074     } catch (...) {
44075       {
44076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44077       };
44078     }
44079   }
44080
44081   jresult = (void *)result;
44082   return jresult;
44083 }
44084
44085
44086 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_0(void * jarg1, void * jarg2, void * jarg3, void * jarg4, void * jarg5) {
44087   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44088   SwigValueWrapper< Dali::Property > arg2 ;
44089   SwigValueWrapper< Dali::Property > arg3 ;
44090   Dali::Vector2 *arg4 = 0 ;
44091   Dali::Vector2 *arg5 = 0 ;
44092   Dali::Property *argp2 ;
44093   Dali::Property *argp3 ;
44094
44095   arg1 = (Dali::PathConstrainer *)jarg1;
44096   argp2 = (Dali::Property *)jarg2;
44097   if (!argp2) {
44098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44099     return ;
44100   }
44101   arg2 = *argp2;
44102   argp3 = (Dali::Property *)jarg3;
44103   if (!argp3) {
44104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44105     return ;
44106   }
44107   arg3 = *argp3;
44108   arg4 = (Dali::Vector2 *)jarg4;
44109   if (!arg4) {
44110     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44111     return ;
44112   }
44113   arg5 = (Dali::Vector2 *)jarg5;
44114   if (!arg5) {
44115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44116     return ;
44117   }
44118   {
44119     try {
44120       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4,(Dali::Vector2 const &)*arg5);
44121     } catch (std::out_of_range& e) {
44122       {
44123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44124       };
44125     } catch (std::exception& e) {
44126       {
44127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44128       };
44129     } catch (Dali::DaliException e) {
44130       {
44131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44132       };
44133     } catch (...) {
44134       {
44135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44136       };
44137     }
44138   }
44139
44140 }
44141
44142
44143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Apply__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
44144   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44145   SwigValueWrapper< Dali::Property > arg2 ;
44146   SwigValueWrapper< Dali::Property > arg3 ;
44147   Dali::Vector2 *arg4 = 0 ;
44148   Dali::Property *argp2 ;
44149   Dali::Property *argp3 ;
44150
44151   arg1 = (Dali::PathConstrainer *)jarg1;
44152   argp2 = (Dali::Property *)jarg2;
44153   if (!argp2) {
44154     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44155     return ;
44156   }
44157   arg2 = *argp2;
44158   argp3 = (Dali::Property *)jarg3;
44159   if (!argp3) {
44160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property", 0);
44161     return ;
44162   }
44163   arg3 = *argp3;
44164   arg4 = (Dali::Vector2 *)jarg4;
44165   if (!arg4) {
44166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
44167     return ;
44168   }
44169   {
44170     try {
44171       (arg1)->Apply(arg2,arg3,(Dali::Vector2 const &)*arg4);
44172     } catch (std::out_of_range& e) {
44173       {
44174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44175       };
44176     } catch (std::exception& e) {
44177       {
44178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44179       };
44180     } catch (Dali::DaliException e) {
44181       {
44182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44183       };
44184     } catch (...) {
44185       {
44186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44187       };
44188     }
44189   }
44190
44191 }
44192
44193
44194 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PathConstrainer_Remove(void * jarg1, void * jarg2) {
44195   Dali::PathConstrainer *arg1 = (Dali::PathConstrainer *) 0 ;
44196   Dali::Handle *arg2 = 0 ;
44197
44198   arg1 = (Dali::PathConstrainer *)jarg1;
44199   arg2 = (Dali::Handle *)jarg2;
44200   if (!arg2) {
44201     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
44202     return ;
44203   }
44204   {
44205     try {
44206       (arg1)->Remove(*arg2);
44207     } catch (std::out_of_range& e) {
44208       {
44209         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44210       };
44211     } catch (std::exception& e) {
44212       {
44213         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44214       };
44215     } catch (Dali::DaliException e) {
44216       {
44217         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44218       };
44219     } catch (...) {
44220       {
44221         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44222       };
44223     }
44224   }
44225
44226 }
44227
44228
44229 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FittingModeDefault_get() {
44230   int jresult ;
44231   Dali::FittingMode::Type result;
44232
44233   result = (Dali::FittingMode::Type)(Dali::FittingMode::Type)Dali::FittingMode::DEFAULT;
44234   jresult = (int)result;
44235   return jresult;
44236 }
44237
44238
44239 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_DEFAULT_get() {
44240   int jresult ;
44241   Dali::SamplingMode::Type result;
44242
44243   result = (Dali::SamplingMode::Type)(Dali::SamplingMode::Type)Dali::SamplingMode::DEFAULT;
44244   jresult = (int)result;
44245   return jresult;
44246 }
44247
44248
44249 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionCreate(void * jarg1) {
44250   unsigned int jresult ;
44251   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44252   bool result;
44253
44254   arg1 = (Dali::NativeImageInterface *)jarg1;
44255   {
44256     try {
44257       result = (bool)(arg1)->GlExtensionCreate();
44258     } catch (std::out_of_range& e) {
44259       {
44260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44261       };
44262     } catch (std::exception& e) {
44263       {
44264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44265       };
44266     } catch (Dali::DaliException e) {
44267       {
44268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44269       };
44270     } catch (...) {
44271       {
44272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44273       };
44274     }
44275   }
44276
44277   jresult = result;
44278   return jresult;
44279 }
44280
44281
44282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_GlExtensionDestroy(void * jarg1) {
44283   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44284
44285   arg1 = (Dali::NativeImageInterface *)jarg1;
44286   {
44287     try {
44288       (arg1)->GlExtensionDestroy();
44289     } catch (std::out_of_range& e) {
44290       {
44291         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44292       };
44293     } catch (std::exception& e) {
44294       {
44295         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44296       };
44297     } catch (Dali::DaliException e) {
44298       {
44299         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44300       };
44301     } catch (...) {
44302       {
44303         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44304       };
44305     }
44306   }
44307
44308 }
44309
44310
44311 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_TargetTexture(void * jarg1) {
44312   unsigned int jresult ;
44313   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44314   unsigned int result;
44315
44316   arg1 = (Dali::NativeImageInterface *)jarg1;
44317   {
44318     try {
44319       result = (unsigned int)(arg1)->TargetTexture();
44320     } catch (std::out_of_range& e) {
44321       {
44322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44323       };
44324     } catch (std::exception& e) {
44325       {
44326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44327       };
44328     } catch (Dali::DaliException e) {
44329       {
44330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44331       };
44332     } catch (...) {
44333       {
44334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44335       };
44336     }
44337   }
44338
44339   jresult = result;
44340   return jresult;
44341 }
44342
44343
44344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageInterface_PrepareTexture(void * jarg1) {
44345   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44346
44347   arg1 = (Dali::NativeImageInterface *)jarg1;
44348   {
44349     try {
44350       (arg1)->PrepareTexture();
44351     } catch (std::out_of_range& e) {
44352       {
44353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44354       };
44355     } catch (std::exception& e) {
44356       {
44357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44358       };
44359     } catch (Dali::DaliException e) {
44360       {
44361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44362       };
44363     } catch (...) {
44364       {
44365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44366       };
44367     }
44368   }
44369
44370 }
44371
44372
44373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetWidth(void * jarg1) {
44374   unsigned int jresult ;
44375   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44376   unsigned int result;
44377
44378   arg1 = (Dali::NativeImageInterface *)jarg1;
44379   {
44380     try {
44381       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetWidth();
44382     } catch (std::out_of_range& e) {
44383       {
44384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44385       };
44386     } catch (std::exception& e) {
44387       {
44388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44389       };
44390     } catch (Dali::DaliException e) {
44391       {
44392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44393       };
44394     } catch (...) {
44395       {
44396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44397       };
44398     }
44399   }
44400
44401   jresult = result;
44402   return jresult;
44403 }
44404
44405
44406 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_GetHeight(void * jarg1) {
44407   unsigned int jresult ;
44408   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44409   unsigned int result;
44410
44411   arg1 = (Dali::NativeImageInterface *)jarg1;
44412   {
44413     try {
44414       result = (unsigned int)((Dali::NativeImageInterface const *)arg1)->GetHeight();
44415     } catch (std::out_of_range& e) {
44416       {
44417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44418       };
44419     } catch (std::exception& e) {
44420       {
44421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44422       };
44423     } catch (Dali::DaliException e) {
44424       {
44425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44426       };
44427     } catch (...) {
44428       {
44429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44430       };
44431     }
44432   }
44433
44434   jresult = result;
44435   return jresult;
44436 }
44437
44438
44439 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_NativeImageInterface_RequiresBlending(void * jarg1) {
44440   unsigned int jresult ;
44441   Dali::NativeImageInterface *arg1 = (Dali::NativeImageInterface *) 0 ;
44442   bool result;
44443
44444   arg1 = (Dali::NativeImageInterface *)jarg1;
44445   {
44446     try {
44447       result = (bool)((Dali::NativeImageInterface const *)arg1)->RequiresBlending();
44448     } catch (std::out_of_range& e) {
44449       {
44450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44451       };
44452     } catch (std::exception& e) {
44453       {
44454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44455       };
44456     } catch (Dali::DaliException e) {
44457       {
44458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44459       };
44460     } catch (...) {
44461       {
44462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44463       };
44464     }
44465   }
44466
44467   jresult = result;
44468   return jresult;
44469 }
44470
44471 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TYPE_get() {
44472   int jresult ;
44473   int result;
44474
44475   result = (int)Dali::CameraActor::Property::TYPE;
44476   jresult = (int)result;
44477   return jresult;
44478 }
44479
44480
44481 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MODE_get() {
44482   int jresult ;
44483   int result;
44484
44485   result = (int)Dali::CameraActor::Property::PROJECTION_MODE;
44486   jresult = (int)result;
44487   return jresult;
44488 }
44489
44490
44491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FIELD_OF_VIEW_get() {
44492   int jresult ;
44493   int result;
44494
44495   result = (int)Dali::CameraActor::Property::FIELD_OF_VIEW;
44496   jresult = (int)result;
44497   return jresult;
44498 }
44499
44500
44501 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_ASPECT_RATIO_get() {
44502   int jresult ;
44503   int result;
44504
44505   result = (int)Dali::CameraActor::Property::ASPECT_RATIO;
44506   jresult = (int)result;
44507   return jresult;
44508 }
44509
44510
44511 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_NEAR_PLANE_DISTANCE_get() {
44512   int jresult ;
44513   int result;
44514
44515   result = (int)Dali::CameraActor::Property::NEAR_PLANE_DISTANCE;
44516   jresult = (int)result;
44517   return jresult;
44518 }
44519
44520
44521 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_FAR_PLANE_DISTANCE_get() {
44522   int jresult ;
44523   int result;
44524
44525   result = (int)Dali::CameraActor::Property::FAR_PLANE_DISTANCE;
44526   jresult = (int)result;
44527   return jresult;
44528 }
44529
44530
44531 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_LEFT_PLANE_DISTANCE_get() {
44532   int jresult ;
44533   int result;
44534
44535   result = (int)Dali::CameraActor::Property::LEFT_PLANE_DISTANCE;
44536   jresult = (int)result;
44537   return jresult;
44538 }
44539
44540
44541 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_RIGHT_PLANE_DISTANCE_get() {
44542   int jresult ;
44543   int result;
44544
44545   result = (int)Dali::CameraActor::Property::RIGHT_PLANE_DISTANCE;
44546   jresult = (int)result;
44547   return jresult;
44548 }
44549
44550
44551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TOP_PLANE_DISTANCE_get() {
44552   int jresult ;
44553   int result;
44554
44555   result = (int)Dali::CameraActor::Property::TOP_PLANE_DISTANCE;
44556   jresult = (int)result;
44557   return jresult;
44558 }
44559
44560
44561 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_BOTTOM_PLANE_DISTANCE_get() {
44562   int jresult ;
44563   int result;
44564
44565   result = (int)Dali::CameraActor::Property::BOTTOM_PLANE_DISTANCE;
44566   jresult = (int)result;
44567   return jresult;
44568 }
44569
44570
44571 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_TARGET_POSITION_get() {
44572   int jresult ;
44573   int result;
44574
44575   result = (int)Dali::CameraActor::Property::TARGET_POSITION;
44576   jresult = (int)result;
44577   return jresult;
44578 }
44579
44580
44581 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_PROJECTION_MATRIX_get() {
44582   int jresult ;
44583   int result;
44584
44585   result = (int)Dali::CameraActor::Property::PROJECTION_MATRIX;
44586   jresult = (int)result;
44587   return jresult;
44588 }
44589
44590
44591 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_VIEW_MATRIX_get() {
44592   int jresult ;
44593   int result;
44594
44595   result = (int)Dali::CameraActor::Property::VIEW_MATRIX;
44596   jresult = (int)result;
44597   return jresult;
44598 }
44599
44600
44601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_Property_INVERT_Y_AXIS_get() {
44602   int jresult ;
44603   int result;
44604
44605   result = (int)Dali::CameraActor::Property::INVERT_Y_AXIS;
44606   jresult = (int)result;
44607   return jresult;
44608 }
44609
44610
44611 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor_Property() {
44612   void * jresult ;
44613   Dali::CameraActor::Property *result = 0 ;
44614
44615   {
44616     try {
44617       result = (Dali::CameraActor::Property *)new Dali::CameraActor::Property();
44618     } catch (std::out_of_range& e) {
44619       {
44620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44621       };
44622     } catch (std::exception& e) {
44623       {
44624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44625       };
44626     } catch (Dali::DaliException e) {
44627       {
44628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44629       };
44630     } catch (...) {
44631       {
44632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44633       };
44634     }
44635   }
44636
44637   jresult = (void *)result;
44638   return jresult;
44639 }
44640
44641
44642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor_Property(void * jarg1) {
44643   Dali::CameraActor::Property *arg1 = (Dali::CameraActor::Property *) 0 ;
44644
44645   arg1 = (Dali::CameraActor::Property *)jarg1;
44646   {
44647     try {
44648       delete arg1;
44649     } catch (std::out_of_range& e) {
44650       {
44651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44652       };
44653     } catch (std::exception& e) {
44654       {
44655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44656       };
44657     } catch (Dali::DaliException e) {
44658       {
44659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44660       };
44661     } catch (...) {
44662       {
44663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44664       };
44665     }
44666   }
44667
44668 }
44669
44670
44671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_0() {
44672   void * jresult ;
44673   Dali::CameraActor *result = 0 ;
44674
44675   {
44676     try {
44677       result = (Dali::CameraActor *)new Dali::CameraActor();
44678     } catch (std::out_of_range& e) {
44679       {
44680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44681       };
44682     } catch (std::exception& e) {
44683       {
44684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44685       };
44686     } catch (Dali::DaliException e) {
44687       {
44688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44689       };
44690     } catch (...) {
44691       {
44692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44693       };
44694     }
44695   }
44696
44697   jresult = (void *)result;
44698   return jresult;
44699 }
44700
44701
44702 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_0() {
44703   void * jresult ;
44704   Dali::CameraActor result;
44705
44706   {
44707     try {
44708       result = Dali::CameraActor::New();
44709     } catch (std::out_of_range& e) {
44710       {
44711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44712       };
44713     } catch (std::exception& e) {
44714       {
44715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44716       };
44717     } catch (Dali::DaliException e) {
44718       {
44719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44720       };
44721     } catch (...) {
44722       {
44723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44724       };
44725     }
44726   }
44727
44728   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44729   return jresult;
44730 }
44731
44732
44733 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_New__SWIG_1(void * jarg1) {
44734   void * jresult ;
44735   Dali::Size *arg1 = 0 ;
44736   Dali::CameraActor result;
44737
44738   arg1 = (Dali::Size *)jarg1;
44739   if (!arg1) {
44740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
44741     return 0;
44742   }
44743   {
44744     try {
44745       result = Dali::CameraActor::New((Dali::Vector2 const &)*arg1);
44746     } catch (std::out_of_range& e) {
44747       {
44748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44749       };
44750     } catch (std::exception& e) {
44751       {
44752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44753       };
44754     } catch (Dali::DaliException e) {
44755       {
44756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44757       };
44758     } catch (...) {
44759       {
44760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44761       };
44762     }
44763   }
44764
44765   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44766   return jresult;
44767 }
44768
44769
44770 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_DownCast(void * jarg1) {
44771   void * jresult ;
44772   Dali::BaseHandle arg1 ;
44773   Dali::BaseHandle *argp1 ;
44774   Dali::CameraActor result;
44775
44776   argp1 = (Dali::BaseHandle *)jarg1;
44777   if (!argp1) {
44778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
44779     return 0;
44780   }
44781   arg1 = *argp1;
44782   {
44783     try {
44784       result = Dali::CameraActor::DownCast(arg1);
44785     } catch (std::out_of_range& e) {
44786       {
44787         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44788       };
44789     } catch (std::exception& e) {
44790       {
44791         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44792       };
44793     } catch (Dali::DaliException e) {
44794       {
44795         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44796       };
44797     } catch (...) {
44798       {
44799         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44800       };
44801     }
44802   }
44803
44804   jresult = new Dali::CameraActor((const Dali::CameraActor &)result);
44805   return jresult;
44806 }
44807
44808
44809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CameraActor(void * jarg1) {
44810   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44811
44812   arg1 = (Dali::CameraActor *)jarg1;
44813   {
44814     try {
44815       delete arg1;
44816     } catch (std::out_of_range& e) {
44817       {
44818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44819       };
44820     } catch (std::exception& e) {
44821       {
44822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44823       };
44824     } catch (Dali::DaliException e) {
44825       {
44826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44827       };
44828     } catch (...) {
44829       {
44830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44831       };
44832     }
44833   }
44834
44835 }
44836
44837
44838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CameraActor__SWIG_1(void * jarg1) {
44839   void * jresult ;
44840   Dali::CameraActor *arg1 = 0 ;
44841   Dali::CameraActor *result = 0 ;
44842
44843   arg1 = (Dali::CameraActor *)jarg1;
44844   if (!arg1) {
44845     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44846     return 0;
44847   }
44848   {
44849     try {
44850       result = (Dali::CameraActor *)new Dali::CameraActor((Dali::CameraActor const &)*arg1);
44851     } catch (std::out_of_range& e) {
44852       {
44853         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44854       };
44855     } catch (std::exception& e) {
44856       {
44857         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44858       };
44859     } catch (Dali::DaliException e) {
44860       {
44861         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44862       };
44863     } catch (...) {
44864       {
44865         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44866       };
44867     }
44868   }
44869
44870   jresult = (void *)result;
44871   return jresult;
44872 }
44873
44874
44875 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_Assign(void * jarg1, void * jarg2) {
44876   void * jresult ;
44877   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44878   Dali::CameraActor *arg2 = 0 ;
44879   Dali::CameraActor *result = 0 ;
44880
44881   arg1 = (Dali::CameraActor *)jarg1;
44882   arg2 = (Dali::CameraActor *)jarg2;
44883   if (!arg2) {
44884     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::CameraActor const & type is null", 0);
44885     return 0;
44886   }
44887   {
44888     try {
44889       result = (Dali::CameraActor *) &(arg1)->operator =((Dali::CameraActor const &)*arg2);
44890     } catch (std::out_of_range& e) {
44891       {
44892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44893       };
44894     } catch (std::exception& e) {
44895       {
44896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44897       };
44898     } catch (Dali::DaliException e) {
44899       {
44900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44901       };
44902     } catch (...) {
44903       {
44904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44905       };
44906     }
44907   }
44908
44909   jresult = (void *)result;
44910   return jresult;
44911 }
44912
44913
44914 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetType(void * jarg1, int jarg2) {
44915   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44916   Dali::Camera::Type arg2 ;
44917
44918   arg1 = (Dali::CameraActor *)jarg1;
44919   arg2 = (Dali::Camera::Type)jarg2;
44920   {
44921     try {
44922       (arg1)->SetType(arg2);
44923     } catch (std::out_of_range& e) {
44924       {
44925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44926       };
44927     } catch (std::exception& e) {
44928       {
44929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44930       };
44931     } catch (Dali::DaliException e) {
44932       {
44933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44934       };
44935     } catch (...) {
44936       {
44937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
44938       };
44939     }
44940   }
44941
44942 }
44943
44944
44945 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetType(void * jarg1) {
44946   int jresult ;
44947   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44948   Dali::Camera::Type result;
44949
44950   arg1 = (Dali::CameraActor *)jarg1;
44951   {
44952     try {
44953       result = (Dali::Camera::Type)((Dali::CameraActor const *)arg1)->GetType();
44954     } catch (std::out_of_range& e) {
44955       {
44956         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
44957       };
44958     } catch (std::exception& e) {
44959       {
44960         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
44961       };
44962     } catch (Dali::DaliException e) {
44963       {
44964         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
44965       };
44966     } catch (...) {
44967       {
44968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
44969       };
44970     }
44971   }
44972
44973   jresult = (int)result;
44974   return jresult;
44975 }
44976
44977
44978 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetProjectionMode(void * jarg1, int jarg2) {
44979   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
44980   Dali::Camera::ProjectionMode arg2 ;
44981
44982   arg1 = (Dali::CameraActor *)jarg1;
44983   arg2 = (Dali::Camera::ProjectionMode)jarg2;
44984   {
44985     try {
44986       (arg1)->SetProjectionMode(arg2);
44987     } catch (std::out_of_range& e) {
44988       {
44989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
44990       };
44991     } catch (std::exception& e) {
44992       {
44993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
44994       };
44995     } catch (Dali::DaliException e) {
44996       {
44997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
44998       };
44999     } catch (...) {
45000       {
45001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45002       };
45003     }
45004   }
45005
45006 }
45007
45008
45009 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_CameraActor_GetProjectionMode(void * jarg1) {
45010   int jresult ;
45011   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45012   Dali::Camera::ProjectionMode result;
45013
45014   arg1 = (Dali::CameraActor *)jarg1;
45015   {
45016     try {
45017       result = (Dali::Camera::ProjectionMode)((Dali::CameraActor const *)arg1)->GetProjectionMode();
45018     } catch (std::out_of_range& e) {
45019       {
45020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45021       };
45022     } catch (std::exception& e) {
45023       {
45024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45025       };
45026     } catch (Dali::DaliException e) {
45027       {
45028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45029       };
45030     } catch (...) {
45031       {
45032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45033       };
45034     }
45035   }
45036
45037   jresult = (int)result;
45038   return jresult;
45039 }
45040
45041
45042 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFieldOfView(void * jarg1, float jarg2) {
45043   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45044   float arg2 ;
45045
45046   arg1 = (Dali::CameraActor *)jarg1;
45047   arg2 = (float)jarg2;
45048   {
45049     try {
45050       (arg1)->SetFieldOfView(arg2);
45051     } catch (std::out_of_range& e) {
45052       {
45053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45054       };
45055     } catch (std::exception& e) {
45056       {
45057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45058       };
45059     } catch (Dali::DaliException e) {
45060       {
45061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45062       };
45063     } catch (...) {
45064       {
45065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45066       };
45067     }
45068   }
45069
45070 }
45071
45072
45073 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFieldOfView(void * jarg1) {
45074   float jresult ;
45075   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45076   float result;
45077
45078   arg1 = (Dali::CameraActor *)jarg1;
45079   {
45080     try {
45081       result = (float)(arg1)->GetFieldOfView();
45082     } catch (std::out_of_range& e) {
45083       {
45084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45085       };
45086     } catch (std::exception& e) {
45087       {
45088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45089       };
45090     } catch (Dali::DaliException e) {
45091       {
45092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45093       };
45094     } catch (...) {
45095       {
45096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45097       };
45098     }
45099   }
45100
45101   jresult = result;
45102   return jresult;
45103 }
45104
45105
45106 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetAspectRatio(void * jarg1, float jarg2) {
45107   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45108   float arg2 ;
45109
45110   arg1 = (Dali::CameraActor *)jarg1;
45111   arg2 = (float)jarg2;
45112   {
45113     try {
45114       (arg1)->SetAspectRatio(arg2);
45115     } catch (std::out_of_range& e) {
45116       {
45117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45118       };
45119     } catch (std::exception& e) {
45120       {
45121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45122       };
45123     } catch (Dali::DaliException e) {
45124       {
45125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45126       };
45127     } catch (...) {
45128       {
45129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45130       };
45131     }
45132   }
45133
45134 }
45135
45136
45137 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetAspectRatio(void * jarg1) {
45138   float jresult ;
45139   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45140   float result;
45141
45142   arg1 = (Dali::CameraActor *)jarg1;
45143   {
45144     try {
45145       result = (float)(arg1)->GetAspectRatio();
45146     } catch (std::out_of_range& e) {
45147       {
45148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45149       };
45150     } catch (std::exception& e) {
45151       {
45152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45153       };
45154     } catch (Dali::DaliException e) {
45155       {
45156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45157       };
45158     } catch (...) {
45159       {
45160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45161       };
45162     }
45163   }
45164
45165   jresult = result;
45166   return jresult;
45167 }
45168
45169
45170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetNearClippingPlane(void * jarg1, float jarg2) {
45171   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45172   float arg2 ;
45173
45174   arg1 = (Dali::CameraActor *)jarg1;
45175   arg2 = (float)jarg2;
45176   {
45177     try {
45178       (arg1)->SetNearClippingPlane(arg2);
45179     } catch (std::out_of_range& e) {
45180       {
45181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45182       };
45183     } catch (std::exception& e) {
45184       {
45185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45186       };
45187     } catch (Dali::DaliException e) {
45188       {
45189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45190       };
45191     } catch (...) {
45192       {
45193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45194       };
45195     }
45196   }
45197
45198 }
45199
45200
45201 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetNearClippingPlane(void * jarg1) {
45202   float jresult ;
45203   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45204   float result;
45205
45206   arg1 = (Dali::CameraActor *)jarg1;
45207   {
45208     try {
45209       result = (float)(arg1)->GetNearClippingPlane();
45210     } catch (std::out_of_range& e) {
45211       {
45212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45213       };
45214     } catch (std::exception& e) {
45215       {
45216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45217       };
45218     } catch (Dali::DaliException e) {
45219       {
45220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45221       };
45222     } catch (...) {
45223       {
45224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45225       };
45226     }
45227   }
45228
45229   jresult = result;
45230   return jresult;
45231 }
45232
45233
45234 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetFarClippingPlane(void * jarg1, float jarg2) {
45235   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45236   float arg2 ;
45237
45238   arg1 = (Dali::CameraActor *)jarg1;
45239   arg2 = (float)jarg2;
45240   {
45241     try {
45242       (arg1)->SetFarClippingPlane(arg2);
45243     } catch (std::out_of_range& e) {
45244       {
45245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45246       };
45247     } catch (std::exception& e) {
45248       {
45249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45250       };
45251     } catch (Dali::DaliException e) {
45252       {
45253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45254       };
45255     } catch (...) {
45256       {
45257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45258       };
45259     }
45260   }
45261
45262 }
45263
45264
45265 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_CameraActor_GetFarClippingPlane(void * jarg1) {
45266   float jresult ;
45267   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45268   float result;
45269
45270   arg1 = (Dali::CameraActor *)jarg1;
45271   {
45272     try {
45273       result = (float)(arg1)->GetFarClippingPlane();
45274     } catch (std::out_of_range& e) {
45275       {
45276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45277       };
45278     } catch (std::exception& e) {
45279       {
45280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45281       };
45282     } catch (Dali::DaliException e) {
45283       {
45284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45285       };
45286     } catch (...) {
45287       {
45288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45289       };
45290     }
45291   }
45292
45293   jresult = result;
45294   return jresult;
45295 }
45296
45297
45298 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetTargetPosition(void * jarg1, void * jarg2) {
45299   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45300   Dali::Vector3 *arg2 = 0 ;
45301
45302   arg1 = (Dali::CameraActor *)jarg1;
45303   arg2 = (Dali::Vector3 *)jarg2;
45304   if (!arg2) {
45305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
45306     return ;
45307   }
45308   {
45309     try {
45310       (arg1)->SetTargetPosition((Dali::Vector3 const &)*arg2);
45311     } catch (std::out_of_range& e) {
45312       {
45313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45314       };
45315     } catch (std::exception& e) {
45316       {
45317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45318       };
45319     } catch (Dali::DaliException e) {
45320       {
45321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45322       };
45323     } catch (...) {
45324       {
45325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45326       };
45327     }
45328   }
45329
45330 }
45331
45332
45333 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CameraActor_GetTargetPosition(void * jarg1) {
45334   void * jresult ;
45335   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45336   Dali::Vector3 result;
45337
45338   arg1 = (Dali::CameraActor *)jarg1;
45339   {
45340     try {
45341       result = ((Dali::CameraActor const *)arg1)->GetTargetPosition();
45342     } catch (std::out_of_range& e) {
45343       {
45344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45345       };
45346     } catch (std::exception& e) {
45347       {
45348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45349       };
45350     } catch (Dali::DaliException e) {
45351       {
45352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45353       };
45354     } catch (...) {
45355       {
45356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45357       };
45358     }
45359   }
45360
45361   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
45362   return jresult;
45363 }
45364
45365
45366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetInvertYAxis(void * jarg1, unsigned int jarg2) {
45367   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45368   bool arg2 ;
45369
45370   arg1 = (Dali::CameraActor *)jarg1;
45371   arg2 = jarg2 ? true : false;
45372   {
45373     try {
45374       (arg1)->SetInvertYAxis(arg2);
45375     } catch (std::out_of_range& e) {
45376       {
45377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45378       };
45379     } catch (std::exception& e) {
45380       {
45381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45382       };
45383     } catch (Dali::DaliException e) {
45384       {
45385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45386       };
45387     } catch (...) {
45388       {
45389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45390       };
45391     }
45392   }
45393
45394 }
45395
45396
45397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_CameraActor_GetInvertYAxis(void * jarg1) {
45398   unsigned int jresult ;
45399   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45400   bool result;
45401
45402   arg1 = (Dali::CameraActor *)jarg1;
45403   {
45404     try {
45405       result = (bool)(arg1)->GetInvertYAxis();
45406     } catch (std::out_of_range& e) {
45407       {
45408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45409       };
45410     } catch (std::exception& e) {
45411       {
45412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45413       };
45414     } catch (Dali::DaliException e) {
45415       {
45416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45417       };
45418     } catch (...) {
45419       {
45420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45421       };
45422     }
45423   }
45424
45425   jresult = result;
45426   return jresult;
45427 }
45428
45429
45430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetPerspectiveProjection(void * jarg1, void * jarg2) {
45431   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45432   Dali::Size *arg2 = 0 ;
45433
45434   arg1 = (Dali::CameraActor *)jarg1;
45435   arg2 = (Dali::Size *)jarg2;
45436   if (!arg2) {
45437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45438     return ;
45439   }
45440   {
45441     try {
45442       (arg1)->SetPerspectiveProjection((Dali::Size const &)*arg2);
45443     } catch (std::out_of_range& e) {
45444       {
45445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45446       };
45447     } catch (std::exception& e) {
45448       {
45449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45450       };
45451     } catch (Dali::DaliException e) {
45452       {
45453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45454       };
45455     } catch (...) {
45456       {
45457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45458       };
45459     }
45460   }
45461
45462 }
45463
45464
45465 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_0(void * jarg1, void * jarg2) {
45466   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45467   Dali::Size *arg2 = 0 ;
45468
45469   arg1 = (Dali::CameraActor *)jarg1;
45470   arg2 = (Dali::Size *)jarg2;
45471   if (!arg2) {
45472     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Size const & type is null", 0);
45473     return ;
45474   }
45475   {
45476     try {
45477       (arg1)->SetOrthographicProjection((Dali::Size const &)*arg2);
45478     } catch (std::out_of_range& e) {
45479       {
45480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45481       };
45482     } catch (std::exception& e) {
45483       {
45484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45485       };
45486     } catch (Dali::DaliException e) {
45487       {
45488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45489       };
45490     } catch (...) {
45491       {
45492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45493       };
45494     }
45495   }
45496
45497 }
45498
45499
45500 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CameraActor_SetOrthographicProjection__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, float jarg6, float jarg7) {
45501   Dali::CameraActor *arg1 = (Dali::CameraActor *) 0 ;
45502   float arg2 ;
45503   float arg3 ;
45504   float arg4 ;
45505   float arg5 ;
45506   float arg6 ;
45507   float arg7 ;
45508
45509   arg1 = (Dali::CameraActor *)jarg1;
45510   arg2 = (float)jarg2;
45511   arg3 = (float)jarg3;
45512   arg4 = (float)jarg4;
45513   arg5 = (float)jarg5;
45514   arg6 = (float)jarg6;
45515   arg7 = (float)jarg7;
45516   {
45517     try {
45518       (arg1)->SetOrthographicProjection(arg2,arg3,arg4,arg5,arg6,arg7);
45519     } catch (std::out_of_range& e) {
45520       {
45521         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45522       };
45523     } catch (std::exception& e) {
45524       {
45525         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45526       };
45527     } catch (Dali::DaliException e) {
45528       {
45529         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45530       };
45531     } catch (...) {
45532       {
45533         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45534       };
45535     }
45536   }
45537
45538 }
45539
45540
45541 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_0() {
45542   void * jresult ;
45543   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45544
45545   {
45546     try {
45547       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >();
45548     } catch (std::out_of_range& e) {
45549       {
45550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45551       };
45552     } catch (std::exception& e) {
45553       {
45554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45555       };
45556     } catch (Dali::DaliException e) {
45557       {
45558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45559       };
45560     } catch (...) {
45561       {
45562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45563       };
45564     }
45565   }
45566
45567   jresult = (void *)result;
45568   return jresult;
45569 }
45570
45571
45572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_1(char * jarg1, void * jarg2) {
45573   void * jresult ;
45574   std::string arg1 ;
45575   Dali::Property::Value arg2 ;
45576   Dali::Property::Value *argp2 ;
45577   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45578
45579   if (!jarg1) {
45580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45581     return 0;
45582   }
45583   (&arg1)->assign(jarg1);
45584   argp2 = (Dali::Property::Value *)jarg2;
45585   if (!argp2) {
45586     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
45587     return 0;
45588   }
45589   arg2 = *argp2;
45590   {
45591     try {
45592       result = (std::pair< std::string,Dali::Property::Value > *)new std::pair< std::string,Dali::Property::Value >(arg1,arg2);
45593     } catch (std::out_of_range& e) {
45594       {
45595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45596       };
45597     } catch (std::exception& e) {
45598       {
45599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45600       };
45601     } catch (Dali::DaliException e) {
45602       {
45603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45604       };
45605     } catch (...) {
45606       {
45607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45608       };
45609     }
45610   }
45611
45612   jresult = (void *)result;
45613   return jresult;
45614 }
45615
45616
45617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StringValuePair__SWIG_2(void * jarg1) {
45618   void * jresult ;
45619   std::pair< std::string,Dali::Property::Value > *arg1 = 0 ;
45620   std::pair< std::string,Dali::Property::Value > *result = 0 ;
45621
45622   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45623   if (!arg1) {
45624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< std::string,Dali::Property::Value > const & type is null", 0);
45625     return 0;
45626   }
45627   {
45628     try {
45629       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);
45630     } catch (std::out_of_range& e) {
45631       {
45632         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45633       };
45634     } catch (std::exception& e) {
45635       {
45636         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45637       };
45638     } catch (Dali::DaliException e) {
45639       {
45640         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45641       };
45642     } catch (...) {
45643       {
45644         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45645       };
45646     }
45647   }
45648
45649   jresult = (void *)result;
45650   return jresult;
45651 }
45652
45653
45654 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_first_set(void * jarg1, char * jarg2) {
45655   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45656   std::string *arg2 = 0 ;
45657
45658   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45659   if (!jarg2) {
45660     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
45661     return ;
45662   }
45663   std::string arg2_str(jarg2);
45664   arg2 = &arg2_str;
45665   if (arg1) (arg1)->first = *arg2;
45666
45667   //argout typemap for const std::string&
45668
45669 }
45670
45671
45672 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_StringValuePair_first_get(void * jarg1) {
45673   char * jresult ;
45674   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45675   std::string *result = 0 ;
45676
45677   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45678   result = (std::string *) & ((arg1)->first);
45679   jresult = SWIG_csharp_string_callback(result->c_str());
45680   return jresult;
45681 }
45682
45683
45684 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StringValuePair_second_set(void * jarg1, void * jarg2) {
45685   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45686   Dali::Property::Value *arg2 = (Dali::Property::Value *) 0 ;
45687
45688   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45689   arg2 = (Dali::Property::Value *)jarg2;
45690   if (arg1) (arg1)->second = *arg2;
45691 }
45692
45693
45694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StringValuePair_second_get(void * jarg1) {
45695   void * jresult ;
45696   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45697   Dali::Property::Value *result = 0 ;
45698
45699   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45700   result = (Dali::Property::Value *)& ((arg1)->second);
45701   jresult = (void *)result;
45702   return jresult;
45703 }
45704
45705
45706 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StringValuePair(void * jarg1) {
45707   std::pair< std::string,Dali::Property::Value > *arg1 = (std::pair< std::string,Dali::Property::Value > *) 0 ;
45708
45709   arg1 = (std::pair< std::string,Dali::Property::Value > *)jarg1;
45710   {
45711     try {
45712       delete arg1;
45713     } catch (std::out_of_range& e) {
45714       {
45715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45716       };
45717     } catch (std::exception& e) {
45718       {
45719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45720       };
45721     } catch (Dali::DaliException e) {
45722       {
45723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45724       };
45725     } catch (...) {
45726       {
45727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45728       };
45729     }
45730   }
45731
45732 }
45733
45734
45735 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Clear(void * jarg1) {
45736   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45737
45738   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45739   {
45740     try {
45741       (arg1)->clear();
45742     } catch (std::out_of_range& e) {
45743       {
45744         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45745       };
45746     } catch (std::exception& e) {
45747       {
45748         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45749       };
45750     } catch (Dali::DaliException e) {
45751       {
45752         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45753       };
45754     } catch (...) {
45755       {
45756         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45757       };
45758     }
45759   }
45760
45761 }
45762
45763
45764 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Add(void * jarg1, void * jarg2) {
45765   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45766   Dali::TouchPoint *arg2 = 0 ;
45767
45768   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45769   arg2 = (Dali::TouchPoint *)jarg2;
45770   if (!arg2) {
45771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
45772     return ;
45773   }
45774   {
45775     try {
45776       (arg1)->push_back((Dali::TouchPoint const &)*arg2);
45777     } catch (std::out_of_range& e) {
45778       {
45779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45780       };
45781     } catch (std::exception& e) {
45782       {
45783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45784       };
45785     } catch (Dali::DaliException e) {
45786       {
45787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45788       };
45789     } catch (...) {
45790       {
45791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45792       };
45793     }
45794   }
45795
45796 }
45797
45798
45799 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_size(void * jarg1) {
45800   unsigned long jresult ;
45801   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45802   std::vector< Dali::TouchPoint >::size_type result;
45803
45804   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45805   {
45806     try {
45807       result = ((std::vector< Dali::TouchPoint > const *)arg1)->size();
45808     } catch (std::out_of_range& e) {
45809       {
45810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45811       };
45812     } catch (std::exception& e) {
45813       {
45814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45815       };
45816     } catch (Dali::DaliException e) {
45817       {
45818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45819       };
45820     } catch (...) {
45821       {
45822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45823       };
45824     }
45825   }
45826
45827   jresult = (unsigned long)result;
45828   return jresult;
45829 }
45830
45831
45832 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchPointContainer_capacity(void * jarg1) {
45833   unsigned long jresult ;
45834   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45835   std::vector< Dali::TouchPoint >::size_type result;
45836
45837   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45838   {
45839     try {
45840       result = ((std::vector< Dali::TouchPoint > const *)arg1)->capacity();
45841     } catch (std::out_of_range& e) {
45842       {
45843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45844       };
45845     } catch (std::exception& e) {
45846       {
45847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45848       };
45849     } catch (Dali::DaliException e) {
45850       {
45851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45852       };
45853     } catch (...) {
45854       {
45855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45856       };
45857     }
45858   }
45859
45860   jresult = (unsigned long)result;
45861   return jresult;
45862 }
45863
45864
45865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_reserve(void * jarg1, unsigned long jarg2) {
45866   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
45867   std::vector< Dali::TouchPoint >::size_type arg2 ;
45868
45869   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45870   arg2 = (std::vector< Dali::TouchPoint >::size_type)jarg2;
45871   {
45872     try {
45873       (arg1)->reserve(arg2);
45874     } catch (std::out_of_range& e) {
45875       {
45876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
45877       };
45878     } catch (std::exception& e) {
45879       {
45880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
45881       };
45882     } catch (Dali::DaliException e) {
45883       {
45884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
45885       };
45886     } catch (...) {
45887       {
45888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
45889       };
45890     }
45891   }
45892
45893 }
45894
45895
45896 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_0() {
45897   void * jresult ;
45898   std::vector< Dali::TouchPoint > *result = 0 ;
45899
45900   {
45901     try {
45902       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >();
45903     } catch (std::out_of_range& e) {
45904       {
45905         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45906       };
45907     } catch (std::exception& e) {
45908       {
45909         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45910       };
45911     } catch (Dali::DaliException e) {
45912       {
45913         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45914       };
45915     } catch (...) {
45916       {
45917         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45918       };
45919     }
45920   }
45921
45922   jresult = (void *)result;
45923   return jresult;
45924 }
45925
45926
45927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_1(void * jarg1) {
45928   void * jresult ;
45929   std::vector< Dali::TouchPoint > *arg1 = 0 ;
45930   std::vector< Dali::TouchPoint > *result = 0 ;
45931
45932   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
45933   if (!arg1) {
45934     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
45935     return 0;
45936   }
45937   {
45938     try {
45939       result = (std::vector< Dali::TouchPoint > *)new std::vector< Dali::TouchPoint >((std::vector< Dali::TouchPoint > const &)*arg1);
45940     } catch (std::out_of_range& e) {
45941       {
45942         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45943       };
45944     } catch (std::exception& e) {
45945       {
45946         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45947       };
45948     } catch (Dali::DaliException e) {
45949       {
45950         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45951       };
45952     } catch (...) {
45953       {
45954         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45955       };
45956     }
45957   }
45958
45959   jresult = (void *)result;
45960   return jresult;
45961 }
45962
45963
45964 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchPointContainer__SWIG_2(int jarg1) {
45965   void * jresult ;
45966   int arg1 ;
45967   std::vector< Dali::TouchPoint > *result = 0 ;
45968
45969   arg1 = (int)jarg1;
45970   {
45971     try {
45972       try {
45973         result = (std::vector< Dali::TouchPoint > *)new_std_vector_Sl_Dali_TouchPoint_Sg___SWIG_2(arg1);
45974       }
45975       catch(std::out_of_range &_e) {
45976         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
45977         return 0;
45978       }
45979
45980     } catch (std::out_of_range& e) {
45981       {
45982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
45983       };
45984     } catch (std::exception& e) {
45985       {
45986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
45987       };
45988     } catch (Dali::DaliException e) {
45989       {
45990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
45991       };
45992     } catch (...) {
45993       {
45994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
45995       };
45996     }
45997   }
45998
45999   jresult = (void *)result;
46000   return jresult;
46001 }
46002
46003
46004 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitemcopy(void * jarg1, int jarg2) {
46005   void * jresult ;
46006   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46007   int arg2 ;
46008   SwigValueWrapper< Dali::TouchPoint > result;
46009
46010   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46011   arg2 = (int)jarg2;
46012   {
46013     try {
46014       try {
46015         result = std_vector_Sl_Dali_TouchPoint_Sg__getitemcopy(arg1,arg2);
46016       }
46017       catch(std::out_of_range &_e) {
46018         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46019         return 0;
46020       }
46021
46022     } catch (std::out_of_range& e) {
46023       {
46024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46025       };
46026     } catch (std::exception& e) {
46027       {
46028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46029       };
46030     } catch (Dali::DaliException e) {
46031       {
46032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46033       };
46034     } catch (...) {
46035       {
46036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46037       };
46038     }
46039   }
46040
46041   jresult = new Dali::TouchPoint((const Dali::TouchPoint &)result);
46042   return jresult;
46043 }
46044
46045
46046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_getitem(void * jarg1, int jarg2) {
46047   void * jresult ;
46048   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46049   int arg2 ;
46050   Dali::TouchPoint *result = 0 ;
46051
46052   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46053   arg2 = (int)jarg2;
46054   {
46055     try {
46056       try {
46057         result = (Dali::TouchPoint *) &std_vector_Sl_Dali_TouchPoint_Sg__getitem(arg1,arg2);
46058       }
46059       catch(std::out_of_range &_e) {
46060         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46061         return 0;
46062       }
46063
46064     } catch (std::out_of_range& e) {
46065       {
46066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46067       };
46068     } catch (std::exception& e) {
46069       {
46070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46071       };
46072     } catch (Dali::DaliException e) {
46073       {
46074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46075       };
46076     } catch (...) {
46077       {
46078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46079       };
46080     }
46081   }
46082
46083   jresult = (void *)result;
46084   return jresult;
46085 }
46086
46087
46088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
46089   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46090   int arg2 ;
46091   Dali::TouchPoint *arg3 = 0 ;
46092
46093   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46094   arg2 = (int)jarg2;
46095   arg3 = (Dali::TouchPoint *)jarg3;
46096   if (!arg3) {
46097     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46098     return ;
46099   }
46100   {
46101     try {
46102       try {
46103         std_vector_Sl_Dali_TouchPoint_Sg__setitem(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46104       }
46105       catch(std::out_of_range &_e) {
46106         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46107         return ;
46108       }
46109
46110     } catch (std::out_of_range& e) {
46111       {
46112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46113       };
46114     } catch (std::exception& e) {
46115       {
46116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46117       };
46118     } catch (Dali::DaliException e) {
46119       {
46120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46121       };
46122     } catch (...) {
46123       {
46124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46125       };
46126     }
46127   }
46128
46129 }
46130
46131
46132 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_AddRange(void * jarg1, void * jarg2) {
46133   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46134   std::vector< Dali::TouchPoint > *arg2 = 0 ;
46135
46136   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46137   arg2 = (std::vector< Dali::TouchPoint > *)jarg2;
46138   if (!arg2) {
46139     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46140     return ;
46141   }
46142   {
46143     try {
46144       std_vector_Sl_Dali_TouchPoint_Sg__AddRange(arg1,(std::vector< Dali::TouchPoint > const &)*arg2);
46145     } catch (std::out_of_range& e) {
46146       {
46147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46148       };
46149     } catch (std::exception& e) {
46150       {
46151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46152       };
46153     } catch (Dali::DaliException e) {
46154       {
46155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46156       };
46157     } catch (...) {
46158       {
46159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46160       };
46161     }
46162   }
46163
46164 }
46165
46166
46167 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
46168   void * jresult ;
46169   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46170   int arg2 ;
46171   int arg3 ;
46172   std::vector< Dali::TouchPoint > *result = 0 ;
46173
46174   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46175   arg2 = (int)jarg2;
46176   arg3 = (int)jarg3;
46177   {
46178     try {
46179       try {
46180         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__GetRange(arg1,arg2,arg3);
46181       }
46182       catch(std::out_of_range &_e) {
46183         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46184         return 0;
46185       }
46186       catch(std::invalid_argument &_e) {
46187         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46188         return 0;
46189       }
46190
46191     } catch (std::out_of_range& e) {
46192       {
46193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46194       };
46195     } catch (std::exception& e) {
46196       {
46197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46198       };
46199     } catch (Dali::DaliException e) {
46200       {
46201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46202       };
46203     } catch (...) {
46204       {
46205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46206       };
46207     }
46208   }
46209
46210   jresult = (void *)result;
46211   return jresult;
46212 }
46213
46214
46215 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
46216   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46217   int arg2 ;
46218   Dali::TouchPoint *arg3 = 0 ;
46219
46220   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46221   arg2 = (int)jarg2;
46222   arg3 = (Dali::TouchPoint *)jarg3;
46223   if (!arg3) {
46224     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46225     return ;
46226   }
46227   {
46228     try {
46229       try {
46230         std_vector_Sl_Dali_TouchPoint_Sg__Insert(arg1,arg2,(Dali::TouchPoint const &)*arg3);
46231       }
46232       catch(std::out_of_range &_e) {
46233         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46234         return ;
46235       }
46236
46237     } catch (std::out_of_range& e) {
46238       {
46239         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46240       };
46241     } catch (std::exception& e) {
46242       {
46243         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46244       };
46245     } catch (Dali::DaliException e) {
46246       {
46247         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46248       };
46249     } catch (...) {
46250       {
46251         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46252       };
46253     }
46254   }
46255
46256 }
46257
46258
46259 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
46260   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46261   int arg2 ;
46262   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46263
46264   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46265   arg2 = (int)jarg2;
46266   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46267   if (!arg3) {
46268     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46269     return ;
46270   }
46271   {
46272     try {
46273       try {
46274         std_vector_Sl_Dali_TouchPoint_Sg__InsertRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46275       }
46276       catch(std::out_of_range &_e) {
46277         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46278         return ;
46279       }
46280
46281     } catch (std::out_of_range& e) {
46282       {
46283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46284       };
46285     } catch (std::exception& e) {
46286       {
46287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46288       };
46289     } catch (Dali::DaliException e) {
46290       {
46291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46292       };
46293     } catch (...) {
46294       {
46295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46296       };
46297     }
46298   }
46299
46300 }
46301
46302
46303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveAt(void * jarg1, int jarg2) {
46304   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46305   int arg2 ;
46306
46307   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46308   arg2 = (int)jarg2;
46309   {
46310     try {
46311       try {
46312         std_vector_Sl_Dali_TouchPoint_Sg__RemoveAt(arg1,arg2);
46313       }
46314       catch(std::out_of_range &_e) {
46315         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46316         return ;
46317       }
46318
46319     } catch (std::out_of_range& e) {
46320       {
46321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46322       };
46323     } catch (std::exception& e) {
46324       {
46325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46326       };
46327     } catch (Dali::DaliException e) {
46328       {
46329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46330       };
46331     } catch (...) {
46332       {
46333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46334       };
46335     }
46336   }
46337
46338 }
46339
46340
46341 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
46342   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46343   int arg2 ;
46344   int arg3 ;
46345
46346   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46347   arg2 = (int)jarg2;
46348   arg3 = (int)jarg3;
46349   {
46350     try {
46351       try {
46352         std_vector_Sl_Dali_TouchPoint_Sg__RemoveRange(arg1,arg2,arg3);
46353       }
46354       catch(std::out_of_range &_e) {
46355         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46356         return ;
46357       }
46358       catch(std::invalid_argument &_e) {
46359         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46360         return ;
46361       }
46362
46363     } catch (std::out_of_range& e) {
46364       {
46365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46366       };
46367     } catch (std::exception& e) {
46368       {
46369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46370       };
46371     } catch (Dali::DaliException e) {
46372       {
46373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46374       };
46375     } catch (...) {
46376       {
46377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46378       };
46379     }
46380   }
46381
46382 }
46383
46384
46385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TouchPointContainer_Repeat(void * jarg1, int jarg2) {
46386   void * jresult ;
46387   Dali::TouchPoint *arg1 = 0 ;
46388   int arg2 ;
46389   std::vector< Dali::TouchPoint > *result = 0 ;
46390
46391   arg1 = (Dali::TouchPoint *)jarg1;
46392   if (!arg1) {
46393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchPoint const & type is null", 0);
46394     return 0;
46395   }
46396   arg2 = (int)jarg2;
46397   {
46398     try {
46399       try {
46400         result = (std::vector< Dali::TouchPoint > *)std_vector_Sl_Dali_TouchPoint_Sg__Repeat((Dali::TouchPoint const &)*arg1,arg2);
46401       }
46402       catch(std::out_of_range &_e) {
46403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46404         return 0;
46405       }
46406
46407     } catch (std::out_of_range& e) {
46408       {
46409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46410       };
46411     } catch (std::exception& e) {
46412       {
46413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46414       };
46415     } catch (Dali::DaliException e) {
46416       {
46417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46418       };
46419     } catch (...) {
46420       {
46421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46422       };
46423     }
46424   }
46425
46426   jresult = (void *)result;
46427   return jresult;
46428 }
46429
46430
46431 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_0(void * jarg1) {
46432   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46433
46434   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46435   {
46436     try {
46437       std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_0(arg1);
46438     } catch (std::out_of_range& e) {
46439       {
46440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46441       };
46442     } catch (std::exception& e) {
46443       {
46444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46445       };
46446     } catch (Dali::DaliException e) {
46447       {
46448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46449       };
46450     } catch (...) {
46451       {
46452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46453       };
46454     }
46455   }
46456
46457 }
46458
46459
46460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
46461   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46462   int arg2 ;
46463   int arg3 ;
46464
46465   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46466   arg2 = (int)jarg2;
46467   arg3 = (int)jarg3;
46468   {
46469     try {
46470       try {
46471         std_vector_Sl_Dali_TouchPoint_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
46472       }
46473       catch(std::out_of_range &_e) {
46474         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46475         return ;
46476       }
46477       catch(std::invalid_argument &_e) {
46478         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
46479         return ;
46480       }
46481
46482     } catch (std::out_of_range& e) {
46483       {
46484         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46485       };
46486     } catch (std::exception& e) {
46487       {
46488         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46489       };
46490     } catch (Dali::DaliException e) {
46491       {
46492         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46493       };
46494     } catch (...) {
46495       {
46496         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46497       };
46498     }
46499   }
46500
46501 }
46502
46503
46504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchPointContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
46505   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46506   int arg2 ;
46507   std::vector< Dali::TouchPoint > *arg3 = 0 ;
46508
46509   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46510   arg2 = (int)jarg2;
46511   arg3 = (std::vector< Dali::TouchPoint > *)jarg3;
46512   if (!arg3) {
46513     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::TouchPoint > const & type is null", 0);
46514     return ;
46515   }
46516   {
46517     try {
46518       try {
46519         std_vector_Sl_Dali_TouchPoint_Sg__SetRange(arg1,arg2,(std::vector< Dali::TouchPoint > const &)*arg3);
46520       }
46521       catch(std::out_of_range &_e) {
46522         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
46523         return ;
46524       }
46525
46526     } catch (std::out_of_range& e) {
46527       {
46528         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46529       };
46530     } catch (std::exception& e) {
46531       {
46532         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46533       };
46534     } catch (Dali::DaliException e) {
46535       {
46536         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46537       };
46538     } catch (...) {
46539       {
46540         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46541       };
46542     }
46543   }
46544
46545 }
46546
46547
46548 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchPointContainer(void * jarg1) {
46549   std::vector< Dali::TouchPoint > *arg1 = (std::vector< Dali::TouchPoint > *) 0 ;
46550
46551   arg1 = (std::vector< Dali::TouchPoint > *)jarg1;
46552   {
46553     try {
46554       delete arg1;
46555     } catch (std::out_of_range& e) {
46556       {
46557         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46558       };
46559     } catch (std::exception& e) {
46560       {
46561         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46562       };
46563     } catch (Dali::DaliException e) {
46564       {
46565         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46566       };
46567     } catch (...) {
46568       {
46569         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46570       };
46571     }
46572   }
46573
46574 }
46575
46576
46577 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_0() {
46578   void * jresult ;
46579   Dali::Rect< int > *result = 0 ;
46580
46581   {
46582     try {
46583       result = (Dali::Rect< int > *)new Dali::Rect< int >();
46584     } catch (std::out_of_range& e) {
46585       {
46586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46587       };
46588     } catch (std::exception& e) {
46589       {
46590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46591       };
46592     } catch (Dali::DaliException e) {
46593       {
46594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46595       };
46596     } catch (...) {
46597       {
46598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46599       };
46600     }
46601   }
46602
46603   jresult = (void *)result;
46604   return jresult;
46605 }
46606
46607
46608 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_1(int jarg1, int jarg2, int jarg3, int jarg4) {
46609   void * jresult ;
46610   int arg1 ;
46611   int arg2 ;
46612   int arg3 ;
46613   int arg4 ;
46614   Dali::Rect< int > *result = 0 ;
46615
46616   arg1 = (int)jarg1;
46617   arg2 = (int)jarg2;
46618   arg3 = (int)jarg3;
46619   arg4 = (int)jarg4;
46620   {
46621     try {
46622       result = (Dali::Rect< int > *)new Dali::Rect< int >(arg1,arg2,arg3,arg4);
46623     } catch (std::out_of_range& e) {
46624       {
46625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46626       };
46627     } catch (std::exception& e) {
46628       {
46629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46630       };
46631     } catch (Dali::DaliException e) {
46632       {
46633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46634       };
46635     } catch (...) {
46636       {
46637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46638       };
46639     }
46640   }
46641
46642   jresult = (void *)result;
46643   return jresult;
46644 }
46645
46646
46647 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Rectangle__SWIG_2(void * jarg1) {
46648   void * jresult ;
46649   Dali::Rect< int > *arg1 = 0 ;
46650   Dali::Rect< int > *result = 0 ;
46651
46652   arg1 = (Dali::Rect< int > *)jarg1;
46653   if (!arg1) {
46654     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46655     return 0;
46656   }
46657   {
46658     try {
46659       result = (Dali::Rect< int > *)new Dali::Rect< int >((Dali::Rect< int > const &)*arg1);
46660     } catch (std::out_of_range& e) {
46661       {
46662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46663       };
46664     } catch (std::exception& e) {
46665       {
46666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46667       };
46668     } catch (Dali::DaliException e) {
46669       {
46670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46671       };
46672     } catch (...) {
46673       {
46674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46675       };
46676     }
46677   }
46678
46679   jresult = (void *)result;
46680   return jresult;
46681 }
46682
46683
46684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Rectangle_Assign(void * jarg1, void * jarg2) {
46685   void * jresult ;
46686   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46687   Dali::Rect< int > *arg2 = 0 ;
46688   Dali::Rect< int > *result = 0 ;
46689
46690   arg1 = (Dali::Rect< int > *)jarg1;
46691   arg2 = (Dali::Rect< int > *)jarg2;
46692   if (!arg2) {
46693     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46694     return 0;
46695   }
46696   {
46697     try {
46698       result = (Dali::Rect< int > *) &(arg1)->operator =((Dali::Rect< int > const &)*arg2);
46699     } catch (std::out_of_range& e) {
46700       {
46701         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46702       };
46703     } catch (std::exception& e) {
46704       {
46705         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46706       };
46707     } catch (Dali::DaliException e) {
46708       {
46709         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46710       };
46711     } catch (...) {
46712       {
46713         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46714       };
46715     }
46716   }
46717
46718   jresult = (void *)result;
46719   return jresult;
46720 }
46721
46722
46723 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_Set(void * jarg1, int jarg2, int jarg3, int jarg4, int jarg5) {
46724   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46725   int arg2 ;
46726   int arg3 ;
46727   int arg4 ;
46728   int arg5 ;
46729
46730   arg1 = (Dali::Rect< int > *)jarg1;
46731   arg2 = (int)jarg2;
46732   arg3 = (int)jarg3;
46733   arg4 = (int)jarg4;
46734   arg5 = (int)jarg5;
46735   {
46736     try {
46737       (arg1)->Set(arg2,arg3,arg4,arg5);
46738     } catch (std::out_of_range& e) {
46739       {
46740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
46741       };
46742     } catch (std::exception& e) {
46743       {
46744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
46745       };
46746     } catch (Dali::DaliException e) {
46747       {
46748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
46749       };
46750     } catch (...) {
46751       {
46752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
46753       };
46754     }
46755   }
46756
46757 }
46758
46759
46760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_IsEmpty(void * jarg1) {
46761   unsigned int jresult ;
46762   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46763   bool result;
46764
46765   arg1 = (Dali::Rect< int > *)jarg1;
46766   {
46767     try {
46768       result = (bool)((Dali::Rect< int > const *)arg1)->IsEmpty();
46769     } catch (std::out_of_range& e) {
46770       {
46771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46772       };
46773     } catch (std::exception& e) {
46774       {
46775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46776       };
46777     } catch (Dali::DaliException e) {
46778       {
46779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46780       };
46781     } catch (...) {
46782       {
46783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46784       };
46785     }
46786   }
46787
46788   jresult = result;
46789   return jresult;
46790 }
46791
46792
46793 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Left(void * jarg1) {
46794   int jresult ;
46795   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46796   int result;
46797
46798   arg1 = (Dali::Rect< int > *)jarg1;
46799   {
46800     try {
46801       result = (int)((Dali::Rect< int > const *)arg1)->Left();
46802     } catch (std::out_of_range& e) {
46803       {
46804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46805       };
46806     } catch (std::exception& e) {
46807       {
46808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46809       };
46810     } catch (Dali::DaliException e) {
46811       {
46812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46813       };
46814     } catch (...) {
46815       {
46816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46817       };
46818     }
46819   }
46820
46821   jresult = result;
46822   return jresult;
46823 }
46824
46825
46826 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Right(void * jarg1) {
46827   int jresult ;
46828   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46829   int result;
46830
46831   arg1 = (Dali::Rect< int > *)jarg1;
46832   {
46833     try {
46834       result = (int)((Dali::Rect< int > const *)arg1)->Right();
46835     } catch (std::out_of_range& e) {
46836       {
46837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46838       };
46839     } catch (std::exception& e) {
46840       {
46841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46842       };
46843     } catch (Dali::DaliException e) {
46844       {
46845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46846       };
46847     } catch (...) {
46848       {
46849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46850       };
46851     }
46852   }
46853
46854   jresult = result;
46855   return jresult;
46856 }
46857
46858
46859 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Top(void * jarg1) {
46860   int jresult ;
46861   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46862   int result;
46863
46864   arg1 = (Dali::Rect< int > *)jarg1;
46865   {
46866     try {
46867       result = (int)((Dali::Rect< int > const *)arg1)->Top();
46868     } catch (std::out_of_range& e) {
46869       {
46870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46871       };
46872     } catch (std::exception& e) {
46873       {
46874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46875       };
46876     } catch (Dali::DaliException e) {
46877       {
46878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46879       };
46880     } catch (...) {
46881       {
46882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46883       };
46884     }
46885   }
46886
46887   jresult = result;
46888   return jresult;
46889 }
46890
46891
46892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Bottom(void * jarg1) {
46893   int jresult ;
46894   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46895   int result;
46896
46897   arg1 = (Dali::Rect< int > *)jarg1;
46898   {
46899     try {
46900       result = (int)((Dali::Rect< int > const *)arg1)->Bottom();
46901     } catch (std::out_of_range& e) {
46902       {
46903         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46904       };
46905     } catch (std::exception& e) {
46906       {
46907         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46908       };
46909     } catch (Dali::DaliException e) {
46910       {
46911         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46912       };
46913     } catch (...) {
46914       {
46915         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46916       };
46917     }
46918   }
46919
46920   jresult = result;
46921   return jresult;
46922 }
46923
46924
46925 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_Area(void * jarg1) {
46926   int jresult ;
46927   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46928   int result;
46929
46930   arg1 = (Dali::Rect< int > *)jarg1;
46931   {
46932     try {
46933       result = (int)((Dali::Rect< int > const *)arg1)->Area();
46934     } catch (std::out_of_range& e) {
46935       {
46936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46937       };
46938     } catch (std::exception& e) {
46939       {
46940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46941       };
46942     } catch (Dali::DaliException e) {
46943       {
46944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46945       };
46946     } catch (...) {
46947       {
46948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46949       };
46950     }
46951   }
46952
46953   jresult = result;
46954   return jresult;
46955 }
46956
46957
46958 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Intersects(void * jarg1, void * jarg2) {
46959   unsigned int jresult ;
46960   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
46961   Dali::Rect< int > *arg2 = 0 ;
46962   bool result;
46963
46964   arg1 = (Dali::Rect< int > *)jarg1;
46965   arg2 = (Dali::Rect< int > *)jarg2;
46966   if (!arg2) {
46967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
46968     return 0;
46969   }
46970   {
46971     try {
46972       result = (bool)((Dali::Rect< int > const *)arg1)->Intersects((Dali::Rect< int > const &)*arg2);
46973     } catch (std::out_of_range& e) {
46974       {
46975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
46976       };
46977     } catch (std::exception& e) {
46978       {
46979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
46980       };
46981     } catch (Dali::DaliException e) {
46982       {
46983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
46984       };
46985     } catch (...) {
46986       {
46987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
46988       };
46989     }
46990   }
46991
46992   jresult = result;
46993   return jresult;
46994 }
46995
46996
46997 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Rectangle_Contains(void * jarg1, void * jarg2) {
46998   unsigned int jresult ;
46999   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47000   Dali::Rect< int > *arg2 = 0 ;
47001   bool result;
47002
47003   arg1 = (Dali::Rect< int > *)jarg1;
47004   arg2 = (Dali::Rect< int > *)jarg2;
47005   if (!arg2) {
47006     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< int > const & type is null", 0);
47007     return 0;
47008   }
47009   {
47010     try {
47011       result = (bool)((Dali::Rect< int > const *)arg1)->Contains((Dali::Rect< int > const &)*arg2);
47012     } catch (std::out_of_range& e) {
47013       {
47014         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47015       };
47016     } catch (std::exception& e) {
47017       {
47018         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47019       };
47020     } catch (Dali::DaliException e) {
47021       {
47022         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47023       };
47024     } catch (...) {
47025       {
47026         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47027       };
47028     }
47029   }
47030
47031   jresult = result;
47032   return jresult;
47033 }
47034
47035
47036 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_x_set(void * jarg1, int jarg2) {
47037   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47038   int arg2 ;
47039
47040   arg1 = (Dali::Rect< int > *)jarg1;
47041   arg2 = (int)jarg2;
47042   if (arg1) (arg1)->x = arg2;
47043 }
47044
47045
47046 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_x_get(void * jarg1) {
47047   int jresult ;
47048   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47049   int result;
47050
47051   arg1 = (Dali::Rect< int > *)jarg1;
47052   result = (int) ((arg1)->x);
47053   jresult = result;
47054   return jresult;
47055 }
47056
47057
47058 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_left_set(void * jarg1, int jarg2) {
47059   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47060   int arg2 ;
47061
47062   arg1 = (Dali::Rect< int > *)jarg1;
47063   arg2 = (int)jarg2;
47064   if (arg1) (arg1)->left = arg2;
47065 }
47066
47067
47068 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_left_get(void * jarg1) {
47069   int jresult ;
47070   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47071   int result;
47072
47073   arg1 = (Dali::Rect< int > *)jarg1;
47074   result = (int) ((arg1)->left);
47075   jresult = result;
47076   return jresult;
47077 }
47078
47079
47080 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_y_set(void * jarg1, int jarg2) {
47081   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47082   int arg2 ;
47083
47084   arg1 = (Dali::Rect< int > *)jarg1;
47085   arg2 = (int)jarg2;
47086   if (arg1) (arg1)->y = arg2;
47087 }
47088
47089
47090 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_y_get(void * jarg1) {
47091   int jresult ;
47092   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47093   int result;
47094
47095   arg1 = (Dali::Rect< int > *)jarg1;
47096   result = (int) ((arg1)->y);
47097   jresult = result;
47098   return jresult;
47099 }
47100
47101
47102 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_right_set(void * jarg1, int jarg2) {
47103   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47104   int arg2 ;
47105
47106   arg1 = (Dali::Rect< int > *)jarg1;
47107   arg2 = (int)jarg2;
47108   if (arg1) (arg1)->right = arg2;
47109 }
47110
47111
47112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_right_get(void * jarg1) {
47113   int jresult ;
47114   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47115   int result;
47116
47117   arg1 = (Dali::Rect< int > *)jarg1;
47118   result = (int) ((arg1)->right);
47119   jresult = result;
47120   return jresult;
47121 }
47122
47123
47124 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_width_set(void * jarg1, int jarg2) {
47125   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47126   int arg2 ;
47127
47128   arg1 = (Dali::Rect< int > *)jarg1;
47129   arg2 = (int)jarg2;
47130   if (arg1) (arg1)->width = arg2;
47131 }
47132
47133
47134 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_width_get(void * jarg1) {
47135   int jresult ;
47136   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47137   int result;
47138
47139   arg1 = (Dali::Rect< int > *)jarg1;
47140   result = (int) ((arg1)->width);
47141   jresult = result;
47142   return jresult;
47143 }
47144
47145
47146 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_bottom_set(void * jarg1, int jarg2) {
47147   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47148   int arg2 ;
47149
47150   arg1 = (Dali::Rect< int > *)jarg1;
47151   arg2 = (int)jarg2;
47152   if (arg1) (arg1)->bottom = arg2;
47153 }
47154
47155
47156 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_bottom_get(void * jarg1) {
47157   int jresult ;
47158   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47159   int result;
47160
47161   arg1 = (Dali::Rect< int > *)jarg1;
47162   result = (int) ((arg1)->bottom);
47163   jresult = result;
47164   return jresult;
47165 }
47166
47167
47168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_height_set(void * jarg1, int jarg2) {
47169   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47170   int arg2 ;
47171
47172   arg1 = (Dali::Rect< int > *)jarg1;
47173   arg2 = (int)jarg2;
47174   if (arg1) (arg1)->height = arg2;
47175 }
47176
47177
47178 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_height_get(void * jarg1) {
47179   int jresult ;
47180   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47181   int result;
47182
47183   arg1 = (Dali::Rect< int > *)jarg1;
47184   result = (int) ((arg1)->height);
47185   jresult = result;
47186   return jresult;
47187 }
47188
47189
47190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Rectangle_top_set(void * jarg1, int jarg2) {
47191   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47192   int arg2 ;
47193
47194   arg1 = (Dali::Rect< int > *)jarg1;
47195   arg2 = (int)jarg2;
47196   if (arg1) (arg1)->top = arg2;
47197 }
47198
47199
47200 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Rectangle_top_get(void * jarg1) {
47201   int jresult ;
47202   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47203   int result;
47204
47205   arg1 = (Dali::Rect< int > *)jarg1;
47206   result = (int) ((arg1)->top);
47207   jresult = result;
47208   return jresult;
47209 }
47210
47211
47212 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Rectangle(void * jarg1) {
47213   Dali::Rect< int > *arg1 = (Dali::Rect< int > *) 0 ;
47214
47215   arg1 = (Dali::Rect< int > *)jarg1;
47216   {
47217     try {
47218       delete arg1;
47219     } catch (std::out_of_range& e) {
47220       {
47221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47222       };
47223     } catch (std::exception& e) {
47224       {
47225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47226       };
47227     } catch (Dali::DaliException e) {
47228       {
47229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47230       };
47231     } catch (...) {
47232       {
47233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47234       };
47235     }
47236   }
47237
47238 }
47239
47240
47241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_0() {
47242   void * jresult ;
47243   Dali::Rect< float > *result = 0 ;
47244
47245   {
47246     try {
47247       result = (Dali::Rect< float > *)new Dali::Rect< float >();
47248     } catch (std::out_of_range& e) {
47249       {
47250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47251       };
47252     } catch (std::exception& e) {
47253       {
47254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47255       };
47256     } catch (Dali::DaliException e) {
47257       {
47258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47259       };
47260     } catch (...) {
47261       {
47262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47263       };
47264     }
47265   }
47266
47267   jresult = (void *)result;
47268   return jresult;
47269 }
47270
47271
47272 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
47273   void * jresult ;
47274   float arg1 ;
47275   float arg2 ;
47276   float arg3 ;
47277   float arg4 ;
47278   Dali::Rect< float > *result = 0 ;
47279
47280   arg1 = (float)jarg1;
47281   arg2 = (float)jarg2;
47282   arg3 = (float)jarg4;
47283   arg4 = (float)jarg3;
47284   {
47285     try {
47286       result = (Dali::Rect< float > *)new Dali::Rect< float >(arg1,arg2,arg3,arg4);
47287     } catch (std::out_of_range& e) {
47288       {
47289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47290       };
47291     } catch (std::exception& e) {
47292       {
47293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47294       };
47295     } catch (Dali::DaliException e) {
47296       {
47297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47298       };
47299     } catch (...) {
47300       {
47301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47302       };
47303     }
47304   }
47305
47306   jresult = (void *)result;
47307   return jresult;
47308 }
47309
47310
47311 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PaddingType__SWIG_2(void * jarg1) {
47312   void * jresult ;
47313   Dali::Rect< float > *arg1 = 0 ;
47314   Dali::Rect< float > *result = 0 ;
47315
47316   arg1 = (Dali::Rect< float > *)jarg1;
47317   if (!arg1) {
47318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47319     return 0;
47320   }
47321   {
47322     try {
47323       result = (Dali::Rect< float > *)new Dali::Rect< float >((Dali::Rect< float > const &)*arg1);
47324     } catch (std::out_of_range& e) {
47325       {
47326         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47327       };
47328     } catch (std::exception& e) {
47329       {
47330         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47331       };
47332     } catch (Dali::DaliException e) {
47333       {
47334         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47335       };
47336     } catch (...) {
47337       {
47338         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47339       };
47340     }
47341   }
47342
47343   jresult = (void *)result;
47344   return jresult;
47345 }
47346
47347
47348 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PaddingType_Assign(void * jarg1, void * jarg2) {
47349   void * jresult ;
47350   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47351   Dali::Rect< float > *arg2 = 0 ;
47352   Dali::Rect< float > *result = 0 ;
47353
47354   arg1 = (Dali::Rect< float > *)jarg1;
47355   arg2 = (Dali::Rect< float > *)jarg2;
47356   if (!arg2) {
47357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Rect< float > const & type is null", 0);
47358     return 0;
47359   }
47360   {
47361     try {
47362       result = (Dali::Rect< float > *) &(arg1)->operator =((Dali::Rect< float > const &)*arg2);
47363     } catch (std::out_of_range& e) {
47364       {
47365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47366       };
47367     } catch (std::exception& e) {
47368       {
47369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47370       };
47371     } catch (Dali::DaliException e) {
47372       {
47373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47374       };
47375     } catch (...) {
47376       {
47377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47378       };
47379     }
47380   }
47381
47382   jresult = (void *)result;
47383   return jresult;
47384 }
47385
47386
47387 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_Set(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
47388   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47389   float arg2 ;
47390   float arg3 ;
47391   float arg4 ;
47392   float arg5 ;
47393
47394   arg1 = (Dali::Rect< float > *)jarg1;
47395   arg2 = (float)jarg2;
47396   arg3 = (float)jarg3;
47397   arg4 = (float)jarg5;
47398   arg5 = (float)jarg4;
47399   {
47400     try {
47401       (arg1)->Set(arg2,arg3,arg4,arg5);
47402     } catch (std::out_of_range& e) {
47403       {
47404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47405       };
47406     } catch (std::exception& e) {
47407       {
47408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47409       };
47410     } catch (Dali::DaliException e) {
47411       {
47412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47413       };
47414     } catch (...) {
47415       {
47416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47417       };
47418     }
47419   }
47420
47421 }
47422
47423
47424 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_left_set(void * jarg1, float jarg2) {
47425   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47426   float arg2 ;
47427
47428   arg1 = (Dali::Rect< float > *)jarg1;
47429   arg2 = (float)jarg2;
47430   if (arg1) (arg1)->left = arg2;
47431 }
47432
47433
47434 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_left_get(void * jarg1) {
47435   float jresult ;
47436   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47437   float result;
47438
47439   arg1 = (Dali::Rect< float > *)jarg1;
47440   result = (float) ((arg1)->left);
47441   jresult = result;
47442   return jresult;
47443 }
47444
47445
47446 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_start_set(void * jarg1, float jarg2) {
47447   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47448   float arg2 ;
47449
47450   arg1 = (Dali::Rect< float > *)jarg1;
47451   arg2 = (float)jarg2;
47452   if (arg1) (arg1)->left = arg2;
47453 }
47454
47455
47456 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_start_get(void * jarg1) {
47457   float jresult ;
47458   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47459   float result;
47460
47461   arg1 = (Dali::Rect< float > *)jarg1;
47462   result = (float) ((arg1)->left);
47463   jresult = result;
47464   return jresult;
47465 }
47466
47467
47468 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_right_set(void * jarg1, float jarg2) {
47469   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47470   float arg2 ;
47471
47472   arg1 = (Dali::Rect< float > *)jarg1;
47473   arg2 = (float)jarg2;
47474   if (arg1) (arg1)->right = arg2;
47475 }
47476
47477
47478 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_right_get(void * jarg1) {
47479   float jresult ;
47480   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47481   float result;
47482
47483   arg1 = (Dali::Rect< float > *)jarg1;
47484   result = (float) ((arg1)->right);
47485   jresult = result;
47486   return jresult;
47487 }
47488
47489
47490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_end_set(void * jarg1, float jarg2) {
47491   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47492   float arg2 ;
47493
47494   arg1 = (Dali::Rect< float > *)jarg1;
47495   arg2 = (float)jarg2;
47496   if (arg1) (arg1)->right = arg2;
47497 }
47498
47499
47500 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_end_get(void * jarg1) {
47501   float jresult ;
47502   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47503   float result;
47504
47505   arg1 = (Dali::Rect< float > *)jarg1;
47506   result = (float) ((arg1)->right);
47507   jresult = result;
47508   return jresult;
47509 }
47510
47511
47512 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_bottom_set(void * jarg1, float jarg2) {
47513   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47514   float arg2 ;
47515
47516   arg1 = (Dali::Rect< float > *)jarg1;
47517   arg2 = (float)jarg2;
47518   if (arg1) (arg1)->bottom = arg2;
47519 }
47520
47521
47522 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_bottom_get(void * jarg1) {
47523   float jresult ;
47524   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47525   float result;
47526
47527   arg1 = (Dali::Rect< float > *)jarg1;
47528   result = (float) ((arg1)->bottom);
47529   jresult = result;
47530   return jresult;
47531 }
47532
47533
47534 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PaddingType_top_set(void * jarg1, float jarg2) {
47535   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47536   float arg2 ;
47537
47538   arg1 = (Dali::Rect< float > *)jarg1;
47539   arg2 = (float)jarg2;
47540   if (arg1) (arg1)->top = arg2;
47541 }
47542
47543
47544 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_PaddingType_top_get(void * jarg1) {
47545   float jresult ;
47546   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47547   float result;
47548
47549   arg1 = (Dali::Rect< float > *)jarg1;
47550   result = (float) ((arg1)->top);
47551   jresult = result;
47552   return jresult;
47553 }
47554
47555
47556 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PaddingType(void * jarg1) {
47557   Dali::Rect< float > *arg1 = (Dali::Rect< float > *) 0 ;
47558
47559   arg1 = (Dali::Rect< float > *)jarg1;
47560   {
47561     try {
47562       delete arg1;
47563     } catch (std::out_of_range& e) {
47564       {
47565         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47566       };
47567     } catch (std::exception& e) {
47568       {
47569         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47570       };
47571     } catch (Dali::DaliException e) {
47572       {
47573         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47574       };
47575     } catch (...) {
47576       {
47577         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47578       };
47579     }
47580   }
47581
47582 }
47583
47584
47585 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorInteger_BaseType_get() {
47586   int jresult ;
47587   int result;
47588
47589   result = (int)Dali::Vector< int >::BaseType;
47590   jresult = (int)result;
47591   return jresult;
47592 }
47593
47594
47595 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_0() {
47596   void * jresult ;
47597   Dali::Vector< int > *result = 0 ;
47598
47599   {
47600     try {
47601       result = (Dali::Vector< int > *)new Dali::Vector< int >();
47602     } catch (std::out_of_range& e) {
47603       {
47604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47605       };
47606     } catch (std::exception& e) {
47607       {
47608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47609       };
47610     } catch (Dali::DaliException e) {
47611       {
47612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47613       };
47614     } catch (...) {
47615       {
47616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47617       };
47618     }
47619   }
47620
47621   jresult = (void *)result;
47622   return jresult;
47623 }
47624
47625
47626 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorInteger(void * jarg1) {
47627   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47628
47629   arg1 = (Dali::Vector< int > *)jarg1;
47630   {
47631     try {
47632       delete arg1;
47633     } catch (std::out_of_range& e) {
47634       {
47635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47636       };
47637     } catch (std::exception& e) {
47638       {
47639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47640       };
47641     } catch (Dali::DaliException e) {
47642       {
47643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47644       };
47645     } catch (...) {
47646       {
47647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47648       };
47649     }
47650   }
47651
47652 }
47653
47654
47655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorInteger__SWIG_1(void * jarg1) {
47656   void * jresult ;
47657   Dali::Vector< int > *arg1 = 0 ;
47658   Dali::Vector< int > *result = 0 ;
47659
47660   arg1 = (Dali::Vector< int > *)jarg1;
47661   if (!arg1) {
47662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47663     return 0;
47664   }
47665   {
47666     try {
47667       result = (Dali::Vector< int > *)new Dali::Vector< int >((Dali::Vector< int > const &)*arg1);
47668     } catch (std::out_of_range& e) {
47669       {
47670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47671       };
47672     } catch (std::exception& e) {
47673       {
47674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47675       };
47676     } catch (Dali::DaliException e) {
47677       {
47678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47679       };
47680     } catch (...) {
47681       {
47682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47683       };
47684     }
47685   }
47686
47687   jresult = (void *)result;
47688   return jresult;
47689 }
47690
47691
47692 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Assign(void * jarg1, void * jarg2) {
47693   void * jresult ;
47694   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47695   Dali::Vector< int > *arg2 = 0 ;
47696   Dali::Vector< int > *result = 0 ;
47697
47698   arg1 = (Dali::Vector< int > *)jarg1;
47699   arg2 = (Dali::Vector< int > *)jarg2;
47700   if (!arg2) {
47701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > const & type is null", 0);
47702     return 0;
47703   }
47704   {
47705     try {
47706       result = (Dali::Vector< int > *) &(arg1)->operator =((Dali::Vector< int > const &)*arg2);
47707     } catch (std::out_of_range& e) {
47708       {
47709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47710       };
47711     } catch (std::exception& e) {
47712       {
47713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47714       };
47715     } catch (Dali::DaliException e) {
47716       {
47717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47718       };
47719     } catch (...) {
47720       {
47721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47722       };
47723     }
47724   }
47725
47726   jresult = (void *)result;
47727   return jresult;
47728 }
47729
47730
47731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Begin(void * jarg1) {
47732   void * jresult ;
47733   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47734   Dali::Vector< int >::Iterator result;
47735
47736   arg1 = (Dali::Vector< int > *)jarg1;
47737   {
47738     try {
47739       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->Begin();
47740     } catch (std::out_of_range& e) {
47741       {
47742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47743       };
47744     } catch (std::exception& e) {
47745       {
47746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47747       };
47748     } catch (Dali::DaliException e) {
47749       {
47750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47751       };
47752     } catch (...) {
47753       {
47754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47755       };
47756     }
47757   }
47758
47759   jresult = (void *)result;
47760   return jresult;
47761 }
47762
47763
47764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_End(void * jarg1) {
47765   void * jresult ;
47766   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47767   Dali::Vector< int >::Iterator result;
47768
47769   arg1 = (Dali::Vector< int > *)jarg1;
47770   {
47771     try {
47772       result = (Dali::Vector< int >::Iterator)((Dali::Vector< int > const *)arg1)->End();
47773     } catch (std::out_of_range& e) {
47774       {
47775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47776       };
47777     } catch (std::exception& e) {
47778       {
47779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47780       };
47781     } catch (Dali::DaliException e) {
47782       {
47783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47784       };
47785     } catch (...) {
47786       {
47787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47788       };
47789     }
47790   }
47791
47792   jresult = (void *)result;
47793   return jresult;
47794 }
47795
47796
47797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
47798   void * jresult ;
47799   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47800   Dali::Vector< int >::SizeType arg2 ;
47801   Dali::Vector< int >::ItemType *result = 0 ;
47802
47803   arg1 = (Dali::Vector< int > *)jarg1;
47804   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47805   {
47806     try {
47807       result = (Dali::Vector< int >::ItemType *) &(arg1)->operator [](arg2);
47808     } catch (std::out_of_range& e) {
47809       {
47810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
47811       };
47812     } catch (std::exception& e) {
47813       {
47814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
47815       };
47816     } catch (Dali::DaliException e) {
47817       {
47818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
47819       };
47820     } catch (...) {
47821       {
47822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
47823       };
47824     }
47825   }
47826
47827   jresult = (void *)result;
47828   return jresult;
47829 }
47830
47831
47832 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_PushBack(void * jarg1, int jarg2) {
47833   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47834   Dali::Vector< int >::ItemType *arg2 = 0 ;
47835   Dali::Vector< int >::ItemType temp2 ;
47836
47837   arg1 = (Dali::Vector< int > *)jarg1;
47838   temp2 = (Dali::Vector< int >::ItemType)jarg2;
47839   arg2 = &temp2;
47840   {
47841     try {
47842       (arg1)->PushBack((Dali::Vector< int >::ItemType const &)*arg2);
47843     } catch (std::out_of_range& e) {
47844       {
47845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47846       };
47847     } catch (std::exception& e) {
47848       {
47849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47850       };
47851     } catch (Dali::DaliException e) {
47852       {
47853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47854       };
47855     } catch (...) {
47856       {
47857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47858       };
47859     }
47860   }
47861
47862 }
47863
47864
47865 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_0(void * jarg1, void * jarg2, int jarg3) {
47866   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47867   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47868   Dali::Vector< int >::ItemType *arg3 = 0 ;
47869   Dali::Vector< int >::ItemType temp3 ;
47870
47871   arg1 = (Dali::Vector< int > *)jarg1;
47872   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47873   temp3 = (Dali::Vector< int >::ItemType)jarg3;
47874   arg3 = &temp3;
47875   {
47876     try {
47877       (arg1)->Insert(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
47878     } catch (std::out_of_range& e) {
47879       {
47880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47881       };
47882     } catch (std::exception& e) {
47883       {
47884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47885       };
47886     } catch (Dali::DaliException e) {
47887       {
47888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47889       };
47890     } catch (...) {
47891       {
47892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47893       };
47894     }
47895   }
47896
47897 }
47898
47899
47900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
47901   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47902   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
47903   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
47904   Dali::Vector< int >::Iterator arg4 = (Dali::Vector< int >::Iterator) 0 ;
47905
47906   arg1 = (Dali::Vector< int > *)jarg1;
47907   arg2 = (Dali::Vector< int >::Iterator)jarg2;
47908   arg3 = (Dali::Vector< int >::Iterator)jarg3;
47909   arg4 = (Dali::Vector< int >::Iterator)jarg4;
47910   {
47911     try {
47912       (arg1)->Insert(arg2,arg3,arg4);
47913     } catch (std::out_of_range& e) {
47914       {
47915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47916       };
47917     } catch (std::exception& e) {
47918       {
47919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47920       };
47921     } catch (Dali::DaliException e) {
47922       {
47923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47924       };
47925     } catch (...) {
47926       {
47927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47928       };
47929     }
47930   }
47931
47932 }
47933
47934
47935 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Reserve(void * jarg1, unsigned long jarg2) {
47936   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47937   Dali::Vector< int >::SizeType arg2 ;
47938
47939   arg1 = (Dali::Vector< int > *)jarg1;
47940   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47941   {
47942     try {
47943       (arg1)->Reserve(arg2);
47944     } catch (std::out_of_range& e) {
47945       {
47946         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47947       };
47948     } catch (std::exception& e) {
47949       {
47950         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47951       };
47952     } catch (Dali::DaliException e) {
47953       {
47954         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47955       };
47956     } catch (...) {
47957       {
47958         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47959       };
47960     }
47961   }
47962
47963 }
47964
47965
47966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
47967   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47968   Dali::Vector< int >::SizeType arg2 ;
47969
47970   arg1 = (Dali::Vector< int > *)jarg1;
47971   arg2 = (Dali::Vector< int >::SizeType)jarg2;
47972   {
47973     try {
47974       (arg1)->Resize(arg2);
47975     } catch (std::out_of_range& e) {
47976       {
47977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
47978       };
47979     } catch (std::exception& e) {
47980       {
47981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
47982       };
47983     } catch (Dali::DaliException e) {
47984       {
47985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
47986       };
47987     } catch (...) {
47988       {
47989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
47990       };
47991     }
47992   }
47993
47994 }
47995
47996
47997 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Resize__SWIG_1(void * jarg1, unsigned long jarg2, int jarg3) {
47998   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
47999   Dali::Vector< int >::SizeType arg2 ;
48000   Dali::Vector< int >::ItemType *arg3 = 0 ;
48001   Dali::Vector< int >::ItemType temp3 ;
48002
48003   arg1 = (Dali::Vector< int > *)jarg1;
48004   arg2 = (Dali::Vector< int >::SizeType)jarg2;
48005   temp3 = (Dali::Vector< int >::ItemType)jarg3;
48006   arg3 = &temp3;
48007   {
48008     try {
48009       (arg1)->Resize(arg2,(Dali::Vector< int >::ItemType const &)*arg3);
48010     } catch (std::out_of_range& e) {
48011       {
48012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48013       };
48014     } catch (std::exception& e) {
48015       {
48016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48017       };
48018     } catch (Dali::DaliException e) {
48019       {
48020         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48021       };
48022     } catch (...) {
48023       {
48024         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48025       };
48026     }
48027   }
48028
48029 }
48030
48031
48032 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_0(void * jarg1, void * jarg2) {
48033   void * jresult ;
48034   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48035   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48036   Dali::Vector< int >::Iterator result;
48037
48038   arg1 = (Dali::Vector< int > *)jarg1;
48039   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48040   {
48041     try {
48042       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2);
48043     } catch (std::out_of_range& e) {
48044       {
48045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48046       };
48047     } catch (std::exception& e) {
48048       {
48049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48050       };
48051     } catch (Dali::DaliException e) {
48052       {
48053         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48054       };
48055     } catch (...) {
48056       {
48057         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48058       };
48059     }
48060   }
48061
48062   jresult = (void *)result;
48063   return jresult;
48064 }
48065
48066
48067 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorInteger_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48068   void * jresult ;
48069   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48070   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48071   Dali::Vector< int >::Iterator arg3 = (Dali::Vector< int >::Iterator) 0 ;
48072   Dali::Vector< int >::Iterator result;
48073
48074   arg1 = (Dali::Vector< int > *)jarg1;
48075   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48076   arg3 = (Dali::Vector< int >::Iterator)jarg3;
48077   {
48078     try {
48079       result = (Dali::Vector< int >::Iterator)(arg1)->Erase(arg2,arg3);
48080     } catch (std::out_of_range& e) {
48081       {
48082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48083       };
48084     } catch (std::exception& e) {
48085       {
48086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48087       };
48088     } catch (Dali::DaliException e) {
48089       {
48090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48091       };
48092     } catch (...) {
48093       {
48094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48095       };
48096     }
48097   }
48098
48099   jresult = (void *)result;
48100   return jresult;
48101 }
48102
48103
48104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Remove(void * jarg1, void * jarg2) {
48105   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48106   Dali::Vector< int >::Iterator arg2 = (Dali::Vector< int >::Iterator) 0 ;
48107
48108   arg1 = (Dali::Vector< int > *)jarg1;
48109   arg2 = (Dali::Vector< int >::Iterator)jarg2;
48110   {
48111     try {
48112       (arg1)->Remove(arg2);
48113     } catch (std::out_of_range& e) {
48114       {
48115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48116       };
48117     } catch (std::exception& e) {
48118       {
48119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48120       };
48121     } catch (Dali::DaliException e) {
48122       {
48123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48124       };
48125     } catch (...) {
48126       {
48127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48128       };
48129     }
48130   }
48131
48132 }
48133
48134
48135 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Swap(void * jarg1, void * jarg2) {
48136   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48137   Dali::Vector< int > *arg2 = 0 ;
48138
48139   arg1 = (Dali::Vector< int > *)jarg1;
48140   arg2 = (Dali::Vector< int > *)jarg2;
48141   if (!arg2) {
48142     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< int > & type is null", 0);
48143     return ;
48144   }
48145   {
48146     try {
48147       (arg1)->Swap(*arg2);
48148     } catch (std::out_of_range& e) {
48149       {
48150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48151       };
48152     } catch (std::exception& e) {
48153       {
48154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48155       };
48156     } catch (Dali::DaliException e) {
48157       {
48158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48159       };
48160     } catch (...) {
48161       {
48162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48163       };
48164     }
48165   }
48166
48167 }
48168
48169
48170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Clear(void * jarg1) {
48171   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48172
48173   arg1 = (Dali::Vector< int > *)jarg1;
48174   {
48175     try {
48176       (arg1)->Clear();
48177     } catch (std::out_of_range& e) {
48178       {
48179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48180       };
48181     } catch (std::exception& e) {
48182       {
48183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48184       };
48185     } catch (Dali::DaliException e) {
48186       {
48187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48188       };
48189     } catch (...) {
48190       {
48191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48192       };
48193     }
48194   }
48195
48196 }
48197
48198
48199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorInteger_Release(void * jarg1) {
48200   Dali::Vector< int > *arg1 = (Dali::Vector< int > *) 0 ;
48201
48202   arg1 = (Dali::Vector< int > *)jarg1;
48203   {
48204     try {
48205       (arg1)->Release();
48206     } catch (std::out_of_range& e) {
48207       {
48208         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48209       };
48210     } catch (std::exception& e) {
48211       {
48212         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48213       };
48214     } catch (Dali::DaliException e) {
48215       {
48216         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48217       };
48218     } catch (...) {
48219       {
48220         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48221       };
48222     }
48223   }
48224
48225 }
48226
48227
48228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorFloat_BaseType_get() {
48229   int jresult ;
48230   int result;
48231
48232   result = (int)Dali::Vector< float >::BaseType;
48233   jresult = (int)result;
48234   return jresult;
48235 }
48236
48237
48238 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_0() {
48239   void * jresult ;
48240   Dali::Vector< float > *result = 0 ;
48241
48242   {
48243     try {
48244       result = (Dali::Vector< float > *)new Dali::Vector< float >();
48245     } catch (std::out_of_range& e) {
48246       {
48247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48248       };
48249     } catch (std::exception& e) {
48250       {
48251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48252       };
48253     } catch (Dali::DaliException e) {
48254       {
48255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48256       };
48257     } catch (...) {
48258       {
48259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48260       };
48261     }
48262   }
48263
48264   jresult = (void *)result;
48265   return jresult;
48266 }
48267
48268
48269 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorFloat(void * jarg1) {
48270   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48271
48272   arg1 = (Dali::Vector< float > *)jarg1;
48273   {
48274     try {
48275       delete arg1;
48276     } catch (std::out_of_range& e) {
48277       {
48278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48279       };
48280     } catch (std::exception& e) {
48281       {
48282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48283       };
48284     } catch (Dali::DaliException e) {
48285       {
48286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48287       };
48288     } catch (...) {
48289       {
48290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48291       };
48292     }
48293   }
48294
48295 }
48296
48297
48298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorFloat__SWIG_1(void * jarg1) {
48299   void * jresult ;
48300   Dali::Vector< float > *arg1 = 0 ;
48301   Dali::Vector< float > *result = 0 ;
48302
48303   arg1 = (Dali::Vector< float > *)jarg1;
48304   if (!arg1) {
48305     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48306     return 0;
48307   }
48308   {
48309     try {
48310       result = (Dali::Vector< float > *)new Dali::Vector< float >((Dali::Vector< float > const &)*arg1);
48311     } catch (std::out_of_range& e) {
48312       {
48313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48314       };
48315     } catch (std::exception& e) {
48316       {
48317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48318       };
48319     } catch (Dali::DaliException e) {
48320       {
48321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48322       };
48323     } catch (...) {
48324       {
48325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48326       };
48327     }
48328   }
48329
48330   jresult = (void *)result;
48331   return jresult;
48332 }
48333
48334
48335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Assign(void * jarg1, void * jarg2) {
48336   void * jresult ;
48337   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48338   Dali::Vector< float > *arg2 = 0 ;
48339   Dali::Vector< float > *result = 0 ;
48340
48341   arg1 = (Dali::Vector< float > *)jarg1;
48342   arg2 = (Dali::Vector< float > *)jarg2;
48343   if (!arg2) {
48344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > const & type is null", 0);
48345     return 0;
48346   }
48347   {
48348     try {
48349       result = (Dali::Vector< float > *) &(arg1)->operator =((Dali::Vector< float > const &)*arg2);
48350     } catch (std::out_of_range& e) {
48351       {
48352         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48353       };
48354     } catch (std::exception& e) {
48355       {
48356         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48357       };
48358     } catch (Dali::DaliException e) {
48359       {
48360         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48361       };
48362     } catch (...) {
48363       {
48364         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48365       };
48366     }
48367   }
48368
48369   jresult = (void *)result;
48370   return jresult;
48371 }
48372
48373
48374 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Begin(void * jarg1) {
48375   void * jresult ;
48376   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48377   Dali::Vector< float >::Iterator result;
48378
48379   arg1 = (Dali::Vector< float > *)jarg1;
48380   {
48381     try {
48382       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->Begin();
48383     } catch (std::out_of_range& e) {
48384       {
48385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48386       };
48387     } catch (std::exception& e) {
48388       {
48389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48390       };
48391     } catch (Dali::DaliException e) {
48392       {
48393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48394       };
48395     } catch (...) {
48396       {
48397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48398       };
48399     }
48400   }
48401
48402   jresult = (void *)result;
48403   return jresult;
48404 }
48405
48406
48407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_End(void * jarg1) {
48408   void * jresult ;
48409   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48410   Dali::Vector< float >::Iterator result;
48411
48412   arg1 = (Dali::Vector< float > *)jarg1;
48413   {
48414     try {
48415       result = (Dali::Vector< float >::Iterator)((Dali::Vector< float > const *)arg1)->End();
48416     } catch (std::out_of_range& e) {
48417       {
48418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48419       };
48420     } catch (std::exception& e) {
48421       {
48422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48423       };
48424     } catch (Dali::DaliException e) {
48425       {
48426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48427       };
48428     } catch (...) {
48429       {
48430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48431       };
48432     }
48433   }
48434
48435   jresult = (void *)result;
48436   return jresult;
48437 }
48438
48439
48440 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
48441   void * jresult ;
48442   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48443   Dali::Vector< float >::SizeType arg2 ;
48444   Dali::Vector< float >::ItemType *result = 0 ;
48445
48446   arg1 = (Dali::Vector< float > *)jarg1;
48447   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48448   {
48449     try {
48450       result = (Dali::Vector< float >::ItemType *) &(arg1)->operator [](arg2);
48451     } catch (std::out_of_range& e) {
48452       {
48453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48454       };
48455     } catch (std::exception& e) {
48456       {
48457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48458       };
48459     } catch (Dali::DaliException e) {
48460       {
48461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48462       };
48463     } catch (...) {
48464       {
48465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48466       };
48467     }
48468   }
48469
48470   jresult = (void *)result;
48471   return jresult;
48472 }
48473
48474
48475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_PushBack(void * jarg1, float jarg2) {
48476   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48477   Dali::Vector< float >::ItemType *arg2 = 0 ;
48478   Dali::Vector< float >::ItemType temp2 ;
48479
48480   arg1 = (Dali::Vector< float > *)jarg1;
48481   temp2 = (Dali::Vector< float >::ItemType)jarg2;
48482   arg2 = &temp2;
48483   {
48484     try {
48485       (arg1)->PushBack((Dali::Vector< float >::ItemType const &)*arg2);
48486     } catch (std::out_of_range& e) {
48487       {
48488         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48489       };
48490     } catch (std::exception& e) {
48491       {
48492         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48493       };
48494     } catch (Dali::DaliException e) {
48495       {
48496         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48497       };
48498     } catch (...) {
48499       {
48500         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48501       };
48502     }
48503   }
48504
48505 }
48506
48507
48508 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_0(void * jarg1, void * jarg2, float jarg3) {
48509   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48510   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48511   Dali::Vector< float >::ItemType *arg3 = 0 ;
48512   Dali::Vector< float >::ItemType temp3 ;
48513
48514   arg1 = (Dali::Vector< float > *)jarg1;
48515   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48516   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48517   arg3 = &temp3;
48518   {
48519     try {
48520       (arg1)->Insert(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48521     } catch (std::out_of_range& e) {
48522       {
48523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48524       };
48525     } catch (std::exception& e) {
48526       {
48527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48528       };
48529     } catch (Dali::DaliException e) {
48530       {
48531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48532       };
48533     } catch (...) {
48534       {
48535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48536       };
48537     }
48538   }
48539
48540 }
48541
48542
48543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
48544   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48545   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48546   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48547   Dali::Vector< float >::Iterator arg4 = (Dali::Vector< float >::Iterator) 0 ;
48548
48549   arg1 = (Dali::Vector< float > *)jarg1;
48550   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48551   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48552   arg4 = (Dali::Vector< float >::Iterator)jarg4;
48553   {
48554     try {
48555       (arg1)->Insert(arg2,arg3,arg4);
48556     } catch (std::out_of_range& e) {
48557       {
48558         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48559       };
48560     } catch (std::exception& e) {
48561       {
48562         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48563       };
48564     } catch (Dali::DaliException e) {
48565       {
48566         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48567       };
48568     } catch (...) {
48569       {
48570         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48571       };
48572     }
48573   }
48574
48575 }
48576
48577
48578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Reserve(void * jarg1, unsigned long jarg2) {
48579   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48580   Dali::Vector< float >::SizeType arg2 ;
48581
48582   arg1 = (Dali::Vector< float > *)jarg1;
48583   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48584   {
48585     try {
48586       (arg1)->Reserve(arg2);
48587     } catch (std::out_of_range& e) {
48588       {
48589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48590       };
48591     } catch (std::exception& e) {
48592       {
48593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48594       };
48595     } catch (Dali::DaliException e) {
48596       {
48597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48598       };
48599     } catch (...) {
48600       {
48601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48602       };
48603     }
48604   }
48605
48606 }
48607
48608 //// ========================= end of part 2 =============================
48609
48610 //// ========================== start part 3 ===============================
48611
48612
48613 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
48614   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48615   Dali::Vector< float >::SizeType arg2 ;
48616
48617   arg1 = (Dali::Vector< float > *)jarg1;
48618   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48619   {
48620     try {
48621       (arg1)->Resize(arg2);
48622     } catch (std::out_of_range& e) {
48623       {
48624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48625       };
48626     } catch (std::exception& e) {
48627       {
48628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48629       };
48630     } catch (Dali::DaliException e) {
48631       {
48632         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48633       };
48634     } catch (...) {
48635       {
48636         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48637       };
48638     }
48639   }
48640
48641 }
48642
48643
48644 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Resize__SWIG_1(void * jarg1, unsigned long jarg2, float jarg3) {
48645   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48646   Dali::Vector< float >::SizeType arg2 ;
48647   Dali::Vector< float >::ItemType *arg3 = 0 ;
48648   Dali::Vector< float >::ItemType temp3 ;
48649
48650   arg1 = (Dali::Vector< float > *)jarg1;
48651   arg2 = (Dali::Vector< float >::SizeType)jarg2;
48652   temp3 = (Dali::Vector< float >::ItemType)jarg3;
48653   arg3 = &temp3;
48654   {
48655     try {
48656       (arg1)->Resize(arg2,(Dali::Vector< float >::ItemType const &)*arg3);
48657     } catch (std::out_of_range& e) {
48658       {
48659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48660       };
48661     } catch (std::exception& e) {
48662       {
48663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48664       };
48665     } catch (Dali::DaliException e) {
48666       {
48667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48668       };
48669     } catch (...) {
48670       {
48671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48672       };
48673     }
48674   }
48675
48676 }
48677
48678
48679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_0(void * jarg1, void * jarg2) {
48680   void * jresult ;
48681   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48682   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48683   Dali::Vector< float >::Iterator result;
48684
48685   arg1 = (Dali::Vector< float > *)jarg1;
48686   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48687   {
48688     try {
48689       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2);
48690     } catch (std::out_of_range& e) {
48691       {
48692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48693       };
48694     } catch (std::exception& e) {
48695       {
48696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48697       };
48698     } catch (Dali::DaliException e) {
48699       {
48700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48701       };
48702     } catch (...) {
48703       {
48704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48705       };
48706     }
48707   }
48708
48709   jresult = (void *)result;
48710   return jresult;
48711 }
48712
48713
48714 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorFloat_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
48715   void * jresult ;
48716   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48717   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48718   Dali::Vector< float >::Iterator arg3 = (Dali::Vector< float >::Iterator) 0 ;
48719   Dali::Vector< float >::Iterator result;
48720
48721   arg1 = (Dali::Vector< float > *)jarg1;
48722   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48723   arg3 = (Dali::Vector< float >::Iterator)jarg3;
48724   {
48725     try {
48726       result = (Dali::Vector< float >::Iterator)(arg1)->Erase(arg2,arg3);
48727     } catch (std::out_of_range& e) {
48728       {
48729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48730       };
48731     } catch (std::exception& e) {
48732       {
48733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48734       };
48735     } catch (Dali::DaliException e) {
48736       {
48737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48738       };
48739     } catch (...) {
48740       {
48741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48742       };
48743     }
48744   }
48745
48746   jresult = (void *)result;
48747   return jresult;
48748 }
48749
48750
48751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Remove(void * jarg1, void * jarg2) {
48752   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48753   Dali::Vector< float >::Iterator arg2 = (Dali::Vector< float >::Iterator) 0 ;
48754
48755   arg1 = (Dali::Vector< float > *)jarg1;
48756   arg2 = (Dali::Vector< float >::Iterator)jarg2;
48757   {
48758     try {
48759       (arg1)->Remove(arg2);
48760     } catch (std::out_of_range& e) {
48761       {
48762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48763       };
48764     } catch (std::exception& e) {
48765       {
48766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48767       };
48768     } catch (Dali::DaliException e) {
48769       {
48770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48771       };
48772     } catch (...) {
48773       {
48774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48775       };
48776     }
48777   }
48778
48779 }
48780
48781
48782 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Swap(void * jarg1, void * jarg2) {
48783   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48784   Dali::Vector< float > *arg2 = 0 ;
48785
48786   arg1 = (Dali::Vector< float > *)jarg1;
48787   arg2 = (Dali::Vector< float > *)jarg2;
48788   if (!arg2) {
48789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float > & type is null", 0);
48790     return ;
48791   }
48792   {
48793     try {
48794       (arg1)->Swap(*arg2);
48795     } catch (std::out_of_range& e) {
48796       {
48797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48798       };
48799     } catch (std::exception& e) {
48800       {
48801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48802       };
48803     } catch (Dali::DaliException e) {
48804       {
48805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48806       };
48807     } catch (...) {
48808       {
48809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48810       };
48811     }
48812   }
48813
48814 }
48815
48816
48817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Clear(void * jarg1) {
48818   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48819
48820   arg1 = (Dali::Vector< float > *)jarg1;
48821   {
48822     try {
48823       (arg1)->Clear();
48824     } catch (std::out_of_range& e) {
48825       {
48826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48827       };
48828     } catch (std::exception& e) {
48829       {
48830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48831       };
48832     } catch (Dali::DaliException e) {
48833       {
48834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48835       };
48836     } catch (...) {
48837       {
48838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48839       };
48840     }
48841   }
48842
48843 }
48844
48845
48846 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorFloat_Release(void * jarg1) {
48847   Dali::Vector< float > *arg1 = (Dali::Vector< float > *) 0 ;
48848
48849   arg1 = (Dali::Vector< float > *)jarg1;
48850   {
48851     try {
48852       (arg1)->Release();
48853     } catch (std::out_of_range& e) {
48854       {
48855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48856       };
48857     } catch (std::exception& e) {
48858       {
48859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48860       };
48861     } catch (Dali::DaliException e) {
48862       {
48863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48864       };
48865     } catch (...) {
48866       {
48867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48868       };
48869     }
48870   }
48871
48872 }
48873
48874
48875 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_BaseType_get() {
48876   int jresult ;
48877   int result;
48878
48879   result = (int)Dali::Vector< unsigned char >::BaseType;
48880   jresult = (int)result;
48881   return jresult;
48882 }
48883
48884
48885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_0() {
48886   void * jresult ;
48887   Dali::Vector< unsigned char > *result = 0 ;
48888
48889   {
48890     try {
48891       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >();
48892     } catch (std::out_of_range& e) {
48893       {
48894         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48895       };
48896     } catch (std::exception& e) {
48897       {
48898         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48899       };
48900     } catch (Dali::DaliException e) {
48901       {
48902         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48903       };
48904     } catch (...) {
48905       {
48906         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48907       };
48908     }
48909   }
48910
48911   jresult = (void *)result;
48912   return jresult;
48913 }
48914
48915
48916 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUnsignedChar(void * jarg1) {
48917   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48918
48919   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48920   {
48921     try {
48922       delete arg1;
48923     } catch (std::out_of_range& e) {
48924       {
48925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
48926       };
48927     } catch (std::exception& e) {
48928       {
48929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
48930       };
48931     } catch (Dali::DaliException e) {
48932       {
48933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
48934       };
48935     } catch (...) {
48936       {
48937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
48938       };
48939     }
48940   }
48941
48942 }
48943
48944
48945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUnsignedChar__SWIG_1(void * jarg1) {
48946   void * jresult ;
48947   Dali::Vector< unsigned char > *arg1 = 0 ;
48948   Dali::Vector< unsigned char > *result = 0 ;
48949
48950   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48951   if (!arg1) {
48952     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48953     return 0;
48954   }
48955   {
48956     try {
48957       result = (Dali::Vector< unsigned char > *)new Dali::Vector< unsigned char >((Dali::Vector< unsigned char > const &)*arg1);
48958     } catch (std::out_of_range& e) {
48959       {
48960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
48961       };
48962     } catch (std::exception& e) {
48963       {
48964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
48965       };
48966     } catch (Dali::DaliException e) {
48967       {
48968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
48969       };
48970     } catch (...) {
48971       {
48972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
48973       };
48974     }
48975   }
48976
48977   jresult = (void *)result;
48978   return jresult;
48979 }
48980
48981
48982 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Assign(void * jarg1, void * jarg2) {
48983   void * jresult ;
48984   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
48985   Dali::Vector< unsigned char > *arg2 = 0 ;
48986   Dali::Vector< unsigned char > *result = 0 ;
48987
48988   arg1 = (Dali::Vector< unsigned char > *)jarg1;
48989   arg2 = (Dali::Vector< unsigned char > *)jarg2;
48990   if (!arg2) {
48991     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > const & type is null", 0);
48992     return 0;
48993   }
48994   {
48995     try {
48996       result = (Dali::Vector< unsigned char > *) &(arg1)->operator =((Dali::Vector< unsigned char > const &)*arg2);
48997     } catch (std::out_of_range& e) {
48998       {
48999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49000       };
49001     } catch (std::exception& e) {
49002       {
49003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49004       };
49005     } catch (Dali::DaliException e) {
49006       {
49007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49008       };
49009     } catch (...) {
49010       {
49011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49012       };
49013     }
49014   }
49015
49016   jresult = (void *)result;
49017   return jresult;
49018 }
49019
49020
49021 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Begin(void * jarg1) {
49022   void * jresult ;
49023   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49024   Dali::Vector< unsigned char >::Iterator result;
49025
49026   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49027   {
49028     try {
49029       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->Begin();
49030     } catch (std::out_of_range& e) {
49031       {
49032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49033       };
49034     } catch (std::exception& e) {
49035       {
49036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49037       };
49038     } catch (Dali::DaliException e) {
49039       {
49040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49041       };
49042     } catch (...) {
49043       {
49044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49045       };
49046     }
49047   }
49048
49049   jresult = (void *)result;
49050   return jresult;
49051 }
49052
49053
49054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_End(void * jarg1) {
49055   void * jresult ;
49056   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49057   Dali::Vector< unsigned char >::Iterator result;
49058
49059   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49060   {
49061     try {
49062       result = (Dali::Vector< unsigned char >::Iterator)((Dali::Vector< unsigned char > const *)arg1)->End();
49063     } catch (std::out_of_range& e) {
49064       {
49065         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49066       };
49067     } catch (std::exception& e) {
49068       {
49069         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49070       };
49071     } catch (Dali::DaliException e) {
49072       {
49073         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49074       };
49075     } catch (...) {
49076       {
49077         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49078       };
49079     }
49080   }
49081
49082   jresult = (void *)result;
49083   return jresult;
49084 }
49085
49086
49087 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49088   void * jresult ;
49089   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49090   Dali::Vector< unsigned char >::SizeType arg2 ;
49091   Dali::Vector< unsigned char >::ItemType *result = 0 ;
49092
49093   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49094   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49095   {
49096     try {
49097       result = (Dali::Vector< unsigned char >::ItemType *) &(arg1)->operator [](arg2);
49098     } catch (std::out_of_range& e) {
49099       {
49100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49101       };
49102     } catch (std::exception& e) {
49103       {
49104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49105       };
49106     } catch (Dali::DaliException e) {
49107       {
49108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49109       };
49110     } catch (...) {
49111       {
49112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49113       };
49114     }
49115   }
49116
49117   jresult = (void *)result;
49118   return jresult;
49119 }
49120
49121
49122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_PushBack(void * jarg1, unsigned char jarg2) {
49123   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49124   Dali::Vector< unsigned char >::ItemType *arg2 = 0 ;
49125   Dali::Vector< unsigned char >::ItemType temp2 ;
49126
49127   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49128   temp2 = (Dali::Vector< unsigned char >::ItemType)jarg2;
49129   arg2 = &temp2;
49130   {
49131     try {
49132       (arg1)->PushBack((Dali::Vector< unsigned char >::ItemType const &)*arg2);
49133     } catch (std::out_of_range& e) {
49134       {
49135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49136       };
49137     } catch (std::exception& e) {
49138       {
49139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49140       };
49141     } catch (Dali::DaliException e) {
49142       {
49143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49144       };
49145     } catch (...) {
49146       {
49147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49148       };
49149     }
49150   }
49151
49152 }
49153
49154
49155 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_0(void * jarg1, unsigned char* jarg2, unsigned char jarg3) {
49156   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49157   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49158   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49159   Dali::Vector< unsigned char >::ItemType temp3 ;
49160
49161   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49162   arg2 = jarg2;
49163   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49164   arg3 = &temp3;
49165   {
49166     try {
49167       (arg1)->Insert(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49168     } catch (std::out_of_range& e) {
49169       {
49170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49171       };
49172     } catch (std::exception& e) {
49173       {
49174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49175       };
49176     } catch (Dali::DaliException e) {
49177       {
49178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49179       };
49180     } catch (...) {
49181       {
49182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49183       };
49184     }
49185   }
49186
49187
49188
49189 }
49190
49191
49192 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Insert__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3, void * jarg4) {
49193   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49194   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49195   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49196   Dali::Vector< unsigned char >::Iterator arg4 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49197
49198   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49199   arg2 = jarg2;
49200   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49201   arg4 = (Dali::Vector< unsigned char >::Iterator)jarg4;
49202   {
49203     try {
49204       (arg1)->Insert(arg2,arg3,arg4);
49205     } catch (std::out_of_range& e) {
49206       {
49207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49208       };
49209     } catch (std::exception& e) {
49210       {
49211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49212       };
49213     } catch (Dali::DaliException e) {
49214       {
49215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49216       };
49217     } catch (...) {
49218       {
49219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49220       };
49221     }
49222   }
49223
49224
49225
49226 }
49227
49228
49229 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Reserve(void * jarg1, unsigned long jarg2) {
49230   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49231   Dali::Vector< unsigned char >::SizeType arg2 ;
49232
49233   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49234   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49235   {
49236     try {
49237       (arg1)->Reserve(arg2);
49238     } catch (std::out_of_range& e) {
49239       {
49240         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49241       };
49242     } catch (std::exception& e) {
49243       {
49244         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49245       };
49246     } catch (Dali::DaliException e) {
49247       {
49248         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49249       };
49250     } catch (...) {
49251       {
49252         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49253       };
49254     }
49255   }
49256
49257 }
49258
49259
49260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49261   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49262   Dali::Vector< unsigned char >::SizeType arg2 ;
49263
49264   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49265   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49266   {
49267     try {
49268       (arg1)->Resize(arg2);
49269     } catch (std::out_of_range& e) {
49270       {
49271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49272       };
49273     } catch (std::exception& e) {
49274       {
49275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49276       };
49277     } catch (Dali::DaliException e) {
49278       {
49279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49280       };
49281     } catch (...) {
49282       {
49283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49284       };
49285     }
49286   }
49287
49288 }
49289
49290
49291 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Resize__SWIG_1(void * jarg1, unsigned long jarg2, unsigned char jarg3) {
49292   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49293   Dali::Vector< unsigned char >::SizeType arg2 ;
49294   Dali::Vector< unsigned char >::ItemType *arg3 = 0 ;
49295   Dali::Vector< unsigned char >::ItemType temp3 ;
49296
49297   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49298   arg2 = (Dali::Vector< unsigned char >::SizeType)jarg2;
49299   temp3 = (Dali::Vector< unsigned char >::ItemType)jarg3;
49300   arg3 = &temp3;
49301   {
49302     try {
49303       (arg1)->Resize(arg2,(Dali::Vector< unsigned char >::ItemType const &)*arg3);
49304     } catch (std::out_of_range& e) {
49305       {
49306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49307       };
49308     } catch (std::exception& e) {
49309       {
49310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49311       };
49312     } catch (Dali::DaliException e) {
49313       {
49314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49315       };
49316     } catch (...) {
49317       {
49318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49319       };
49320     }
49321   }
49322
49323 }
49324
49325
49326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_0(void * jarg1, unsigned char* jarg2) {
49327   void * jresult ;
49328   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49329   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49330   Dali::Vector< unsigned char >::Iterator result;
49331
49332   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49333   arg2 = jarg2;
49334   {
49335     try {
49336       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2);
49337     } catch (std::out_of_range& e) {
49338       {
49339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49340       };
49341     } catch (std::exception& e) {
49342       {
49343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49344       };
49345     } catch (Dali::DaliException e) {
49346       {
49347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49348       };
49349     } catch (...) {
49350       {
49351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49352       };
49353     }
49354   }
49355
49356   jresult = (void *)result;
49357
49358
49359   return jresult;
49360 }
49361
49362
49363 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Erase__SWIG_1(void * jarg1, unsigned char* jarg2, void * jarg3) {
49364   void * jresult ;
49365   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49366   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49367   Dali::Vector< unsigned char >::Iterator arg3 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49368   Dali::Vector< unsigned char >::Iterator result;
49369
49370   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49371   arg2 = jarg2;
49372   arg3 = (Dali::Vector< unsigned char >::Iterator)jarg3;
49373   {
49374     try {
49375       result = (Dali::Vector< unsigned char >::Iterator)(arg1)->Erase(arg2,arg3);
49376     } catch (std::out_of_range& e) {
49377       {
49378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49379       };
49380     } catch (std::exception& e) {
49381       {
49382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49383       };
49384     } catch (Dali::DaliException e) {
49385       {
49386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49387       };
49388     } catch (...) {
49389       {
49390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49391       };
49392     }
49393   }
49394
49395   jresult = (void *)result;
49396
49397
49398   return jresult;
49399 }
49400
49401
49402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Remove(void * jarg1, unsigned char* jarg2) {
49403   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49404   Dali::Vector< unsigned char >::Iterator arg2 = (Dali::Vector< unsigned char >::Iterator) 0 ;
49405
49406   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49407   arg2 = jarg2;
49408   {
49409     try {
49410       (arg1)->Remove(arg2);
49411     } catch (std::out_of_range& e) {
49412       {
49413         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49414       };
49415     } catch (std::exception& e) {
49416       {
49417         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49418       };
49419     } catch (Dali::DaliException e) {
49420       {
49421         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49422       };
49423     } catch (...) {
49424       {
49425         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49426       };
49427     }
49428   }
49429
49430
49431
49432 }
49433
49434
49435 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Swap(void * jarg1, void * jarg2) {
49436   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49437   Dali::Vector< unsigned char > *arg2 = 0 ;
49438
49439   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49440   arg2 = (Dali::Vector< unsigned char > *)jarg2;
49441   if (!arg2) {
49442     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< unsigned char > & type is null", 0);
49443     return ;
49444   }
49445   {
49446     try {
49447       (arg1)->Swap(*arg2);
49448     } catch (std::out_of_range& e) {
49449       {
49450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49451       };
49452     } catch (std::exception& e) {
49453       {
49454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49455       };
49456     } catch (Dali::DaliException e) {
49457       {
49458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49459       };
49460     } catch (...) {
49461       {
49462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49463       };
49464     }
49465   }
49466
49467 }
49468
49469
49470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Clear(void * jarg1) {
49471   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49472
49473   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49474   {
49475     try {
49476       (arg1)->Clear();
49477     } catch (std::out_of_range& e) {
49478       {
49479         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49480       };
49481     } catch (std::exception& e) {
49482       {
49483         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49484       };
49485     } catch (Dali::DaliException e) {
49486       {
49487         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49488       };
49489     } catch (...) {
49490       {
49491         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49492       };
49493     }
49494   }
49495
49496 }
49497
49498
49499 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUnsignedChar_Release(void * jarg1) {
49500   Dali::Vector< unsigned char > *arg1 = (Dali::Vector< unsigned char > *) 0 ;
49501
49502   arg1 = (Dali::Vector< unsigned char > *)jarg1;
49503   {
49504     try {
49505       (arg1)->Release();
49506     } catch (std::out_of_range& e) {
49507       {
49508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49509       };
49510     } catch (std::exception& e) {
49511       {
49512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49513       };
49514     } catch (Dali::DaliException e) {
49515       {
49516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49517       };
49518     } catch (...) {
49519       {
49520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49521       };
49522     }
49523   }
49524
49525 }
49526
49527
49528 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VectorUint16Pair_BaseType_get() {
49529   int jresult ;
49530   int result;
49531
49532   result = (int)Dali::Vector< Dali::Uint16Pair >::BaseType;
49533   jresult = (int)result;
49534   return jresult;
49535 }
49536
49537
49538 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_0() {
49539   void * jresult ;
49540   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49541
49542   {
49543     try {
49544       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >();
49545     } catch (std::out_of_range& e) {
49546       {
49547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49548       };
49549     } catch (std::exception& e) {
49550       {
49551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49552       };
49553     } catch (Dali::DaliException e) {
49554       {
49555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49556       };
49557     } catch (...) {
49558       {
49559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49560       };
49561     }
49562   }
49563
49564   jresult = (void *)result;
49565   return jresult;
49566 }
49567
49568
49569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VectorUint16Pair(void * jarg1) {
49570   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49571
49572   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49573   {
49574     try {
49575       delete arg1;
49576     } catch (std::out_of_range& e) {
49577       {
49578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49579       };
49580     } catch (std::exception& e) {
49581       {
49582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49583       };
49584     } catch (Dali::DaliException e) {
49585       {
49586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49587       };
49588     } catch (...) {
49589       {
49590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49591       };
49592     }
49593   }
49594
49595 }
49596
49597
49598 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VectorUint16Pair__SWIG_1(void * jarg1) {
49599   void * jresult ;
49600   Dali::Vector< Dali::Uint16Pair > *arg1 = 0 ;
49601   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49602
49603   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49604   if (!arg1) {
49605     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49606     return 0;
49607   }
49608   {
49609     try {
49610       result = (Dali::Vector< Dali::Uint16Pair > *)new Dali::Vector< Dali::Uint16Pair >((Dali::Vector< Dali::Uint16Pair > const &)*arg1);
49611     } catch (std::out_of_range& e) {
49612       {
49613         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49614       };
49615     } catch (std::exception& e) {
49616       {
49617         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49618       };
49619     } catch (Dali::DaliException e) {
49620       {
49621         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49622       };
49623     } catch (...) {
49624       {
49625         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49626       };
49627     }
49628   }
49629
49630   jresult = (void *)result;
49631   return jresult;
49632 }
49633
49634
49635 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Assign(void * jarg1, void * jarg2) {
49636   void * jresult ;
49637   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49638   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
49639   Dali::Vector< Dali::Uint16Pair > *result = 0 ;
49640
49641   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49642   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
49643   if (!arg2) {
49644     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > const & type is null", 0);
49645     return 0;
49646   }
49647   {
49648     try {
49649       result = (Dali::Vector< Dali::Uint16Pair > *) &(arg1)->operator =((Dali::Vector< Dali::Uint16Pair > const &)*arg2);
49650     } catch (std::out_of_range& e) {
49651       {
49652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49653       };
49654     } catch (std::exception& e) {
49655       {
49656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49657       };
49658     } catch (Dali::DaliException e) {
49659       {
49660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49661       };
49662     } catch (...) {
49663       {
49664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49665       };
49666     }
49667   }
49668
49669   jresult = (void *)result;
49670   return jresult;
49671 }
49672
49673
49674 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Begin(void * jarg1) {
49675   void * jresult ;
49676   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49677   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49678
49679   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49680   {
49681     try {
49682       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->Begin();
49683     } catch (std::out_of_range& e) {
49684       {
49685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49686       };
49687     } catch (std::exception& e) {
49688       {
49689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49690       };
49691     } catch (Dali::DaliException e) {
49692       {
49693         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49694       };
49695     } catch (...) {
49696       {
49697         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49698       };
49699     }
49700   }
49701
49702   jresult = (void *)result;
49703   return jresult;
49704 }
49705
49706
49707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_End(void * jarg1) {
49708   void * jresult ;
49709   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49710   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49711
49712   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49713   {
49714     try {
49715       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)((Dali::Vector< Dali::Uint16Pair > const *)arg1)->End();
49716     } catch (std::out_of_range& e) {
49717       {
49718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49719       };
49720     } catch (std::exception& e) {
49721       {
49722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49723       };
49724     } catch (Dali::DaliException e) {
49725       {
49726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49727       };
49728     } catch (...) {
49729       {
49730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49731       };
49732     }
49733   }
49734
49735   jresult = (void *)result;
49736   return jresult;
49737 }
49738
49739
49740 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_ValueOfIndex__SWIG_0(void * jarg1, unsigned long jarg2) {
49741   void * jresult ;
49742   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49743   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49744   Dali::Vector< Dali::Uint16Pair >::ItemType *result = 0 ;
49745
49746   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49747   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49748   {
49749     try {
49750       result = (Dali::Vector< Dali::Uint16Pair >::ItemType *) &(arg1)->operator [](arg2);
49751     } catch (std::out_of_range& e) {
49752       {
49753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49754       };
49755     } catch (std::exception& e) {
49756       {
49757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49758       };
49759     } catch (Dali::DaliException e) {
49760       {
49761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
49762       };
49763     } catch (...) {
49764       {
49765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
49766       };
49767     }
49768   }
49769
49770   jresult = (void *)result;
49771   return jresult;
49772 }
49773
49774
49775 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_PushBack(void * jarg1, void * jarg2) {
49776   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49777   Dali::Vector< Dali::Uint16Pair >::ItemType *arg2 = 0 ;
49778
49779   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49780   arg2 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg2;
49781   if (!arg2) {
49782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49783     return ;
49784   }
49785   {
49786     try {
49787       (arg1)->PushBack((Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg2);
49788     } catch (std::out_of_range& e) {
49789       {
49790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49791       };
49792     } catch (std::exception& e) {
49793       {
49794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49795       };
49796     } catch (Dali::DaliException e) {
49797       {
49798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49799       };
49800     } catch (...) {
49801       {
49802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49803       };
49804     }
49805   }
49806
49807 }
49808
49809
49810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
49811   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49812   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49813   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49814
49815   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49816   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49817   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49818   if (!arg3) {
49819     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49820     return ;
49821   }
49822   {
49823     try {
49824       (arg1)->Insert(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49825     } catch (std::out_of_range& e) {
49826       {
49827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49828       };
49829     } catch (std::exception& e) {
49830       {
49831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49832       };
49833     } catch (Dali::DaliException e) {
49834       {
49835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49836       };
49837     } catch (...) {
49838       {
49839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49840       };
49841     }
49842   }
49843
49844 }
49845
49846
49847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Insert__SWIG_1(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
49848   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49849   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49850   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49851   Dali::Vector< Dali::Uint16Pair >::Iterator arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49852
49853   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49854   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49855   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
49856   arg4 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg4;
49857   {
49858     try {
49859       (arg1)->Insert(arg2,arg3,arg4);
49860     } catch (std::out_of_range& e) {
49861       {
49862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49863       };
49864     } catch (std::exception& e) {
49865       {
49866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49867       };
49868     } catch (Dali::DaliException e) {
49869       {
49870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49871       };
49872     } catch (...) {
49873       {
49874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49875       };
49876     }
49877   }
49878
49879 }
49880
49881
49882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Reserve(void * jarg1, unsigned long jarg2) {
49883   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49884   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49885
49886   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49887   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49888   {
49889     try {
49890       (arg1)->Reserve(arg2);
49891     } catch (std::out_of_range& e) {
49892       {
49893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49894       };
49895     } catch (std::exception& e) {
49896       {
49897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49898       };
49899     } catch (Dali::DaliException e) {
49900       {
49901         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49902       };
49903     } catch (...) {
49904       {
49905         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49906       };
49907     }
49908   }
49909
49910 }
49911
49912
49913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_0(void * jarg1, unsigned long jarg2) {
49914   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49915   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49916
49917   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49918   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49919   {
49920     try {
49921       (arg1)->Resize(arg2);
49922     } catch (std::out_of_range& e) {
49923       {
49924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49925       };
49926     } catch (std::exception& e) {
49927       {
49928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49929       };
49930     } catch (Dali::DaliException e) {
49931       {
49932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49933       };
49934     } catch (...) {
49935       {
49936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49937       };
49938     }
49939   }
49940
49941 }
49942
49943
49944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Resize__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3) {
49945   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49946   Dali::Vector< Dali::Uint16Pair >::SizeType arg2 ;
49947   Dali::Vector< Dali::Uint16Pair >::ItemType *arg3 = 0 ;
49948
49949   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49950   arg2 = (Dali::Vector< Dali::Uint16Pair >::SizeType)jarg2;
49951   arg3 = (Dali::Vector< Dali::Uint16Pair >::ItemType *)jarg3;
49952   if (!arg3) {
49953     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair >::ItemType const & type is null", 0);
49954     return ;
49955   }
49956   {
49957     try {
49958       (arg1)->Resize(arg2,(Dali::Vector< Dali::Uint16Pair >::ItemType const &)*arg3);
49959     } catch (std::out_of_range& e) {
49960       {
49961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
49962       };
49963     } catch (std::exception& e) {
49964       {
49965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
49966       };
49967     } catch (Dali::DaliException e) {
49968       {
49969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
49970       };
49971     } catch (...) {
49972       {
49973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
49974       };
49975     }
49976   }
49977
49978 }
49979
49980
49981 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_0(void * jarg1, void * jarg2) {
49982   void * jresult ;
49983   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
49984   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
49985   Dali::Vector< Dali::Uint16Pair >::Iterator result;
49986
49987   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
49988   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
49989   {
49990     try {
49991       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2);
49992     } catch (std::out_of_range& e) {
49993       {
49994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
49995       };
49996     } catch (std::exception& e) {
49997       {
49998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
49999       };
50000     } catch (Dali::DaliException e) {
50001       {
50002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50003       };
50004     } catch (...) {
50005       {
50006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50007       };
50008     }
50009   }
50010
50011   jresult = (void *)result;
50012   return jresult;
50013 }
50014
50015
50016 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Erase__SWIG_1(void * jarg1, void * jarg2, void * jarg3) {
50017   void * jresult ;
50018   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50019   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50020   Dali::Vector< Dali::Uint16Pair >::Iterator arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50021   Dali::Vector< Dali::Uint16Pair >::Iterator result;
50022
50023   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50024   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50025   arg3 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg3;
50026   {
50027     try {
50028       result = (Dali::Vector< Dali::Uint16Pair >::Iterator)(arg1)->Erase(arg2,arg3);
50029     } catch (std::out_of_range& e) {
50030       {
50031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50032       };
50033     } catch (std::exception& e) {
50034       {
50035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50036       };
50037     } catch (Dali::DaliException e) {
50038       {
50039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50040       };
50041     } catch (...) {
50042       {
50043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50044       };
50045     }
50046   }
50047
50048   jresult = (void *)result;
50049   return jresult;
50050 }
50051
50052
50053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Remove(void * jarg1, void * jarg2) {
50054   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50055   Dali::Vector< Dali::Uint16Pair >::Iterator arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator) 0 ;
50056
50057   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50058   arg2 = (Dali::Vector< Dali::Uint16Pair >::Iterator)jarg2;
50059   {
50060     try {
50061       (arg1)->Remove(arg2);
50062     } catch (std::out_of_range& e) {
50063       {
50064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50065       };
50066     } catch (std::exception& e) {
50067       {
50068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50069       };
50070     } catch (Dali::DaliException e) {
50071       {
50072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50073       };
50074     } catch (...) {
50075       {
50076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50077       };
50078     }
50079   }
50080
50081 }
50082
50083
50084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Swap(void * jarg1, void * jarg2) {
50085   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50086   Dali::Vector< Dali::Uint16Pair > *arg2 = 0 ;
50087
50088   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50089   arg2 = (Dali::Vector< Dali::Uint16Pair > *)jarg2;
50090   if (!arg2) {
50091     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< Dali::Uint16Pair > & type is null", 0);
50092     return ;
50093   }
50094   {
50095     try {
50096       (arg1)->Swap(*arg2);
50097     } catch (std::out_of_range& e) {
50098       {
50099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50100       };
50101     } catch (std::exception& e) {
50102       {
50103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50104       };
50105     } catch (Dali::DaliException e) {
50106       {
50107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50108       };
50109     } catch (...) {
50110       {
50111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50112       };
50113     }
50114   }
50115
50116 }
50117
50118
50119 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Clear(void * jarg1) {
50120   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50121
50122   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50123   {
50124     try {
50125       (arg1)->Clear();
50126     } catch (std::out_of_range& e) {
50127       {
50128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50129       };
50130     } catch (std::exception& e) {
50131       {
50132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50133       };
50134     } catch (Dali::DaliException e) {
50135       {
50136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50137       };
50138     } catch (...) {
50139       {
50140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50141       };
50142     }
50143   }
50144
50145 }
50146
50147
50148 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VectorUint16Pair_Release(void * jarg1) {
50149   Dali::Vector< Dali::Uint16Pair > *arg1 = (Dali::Vector< Dali::Uint16Pair > *) 0 ;
50150
50151   arg1 = (Dali::Vector< Dali::Uint16Pair > *)jarg1;
50152   {
50153     try {
50154       (arg1)->Release();
50155     } catch (std::out_of_range& e) {
50156       {
50157         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50158       };
50159     } catch (std::exception& e) {
50160       {
50161         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50162       };
50163     } catch (Dali::DaliException e) {
50164       {
50165         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50166       };
50167     } catch (...) {
50168       {
50169         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50170       };
50171     }
50172   }
50173
50174 }
50175
50176
50177 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VoidSignal() {
50178   void * jresult ;
50179   Dali::Signal< void () > *result = 0 ;
50180
50181   {
50182     try {
50183       result = (Dali::Signal< void () > *)new Dali::Signal< void () >();
50184     } catch (std::out_of_range& e) {
50185       {
50186         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50187       };
50188     } catch (std::exception& e) {
50189       {
50190         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50191       };
50192     } catch (Dali::DaliException e) {
50193       {
50194         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50195       };
50196     } catch (...) {
50197       {
50198         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50199       };
50200     }
50201   }
50202
50203   jresult = (void *)result;
50204   return jresult;
50205 }
50206
50207
50208 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VoidSignal(void * jarg1) {
50209   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50210
50211   arg1 = (Dali::Signal< void () > *)jarg1;
50212   {
50213     try {
50214       delete arg1;
50215     } catch (std::out_of_range& e) {
50216       {
50217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50218       };
50219     } catch (std::exception& e) {
50220       {
50221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50222       };
50223     } catch (Dali::DaliException e) {
50224       {
50225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50226       };
50227     } catch (...) {
50228       {
50229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50230       };
50231     }
50232   }
50233
50234 }
50235
50236
50237 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VoidSignal_Empty(void * jarg1) {
50238   unsigned int jresult ;
50239   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50240   bool result;
50241
50242   arg1 = (Dali::Signal< void () > *)jarg1;
50243   {
50244     try {
50245       result = (bool)((Dali::Signal< void () > const *)arg1)->Empty();
50246     } catch (std::out_of_range& e) {
50247       {
50248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50249       };
50250     } catch (std::exception& e) {
50251       {
50252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50253       };
50254     } catch (Dali::DaliException e) {
50255       {
50256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50257       };
50258     } catch (...) {
50259       {
50260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50261       };
50262     }
50263   }
50264
50265   jresult = result;
50266   return jresult;
50267 }
50268
50269
50270 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VoidSignal_GetConnectionCount(void * jarg1) {
50271   unsigned long jresult ;
50272   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50273   std::size_t result;
50274
50275   arg1 = (Dali::Signal< void () > *)jarg1;
50276   {
50277     try {
50278       result = ((Dali::Signal< void () > const *)arg1)->GetConnectionCount();
50279     } catch (std::out_of_range& e) {
50280       {
50281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50282       };
50283     } catch (std::exception& e) {
50284       {
50285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50286       };
50287     } catch (Dali::DaliException e) {
50288       {
50289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50290       };
50291     } catch (...) {
50292       {
50293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50294       };
50295     }
50296   }
50297
50298   jresult = (unsigned long)result;
50299   return jresult;
50300 }
50301
50302
50303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_0(void * jarg1, void * jarg2) {
50304   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50305   void (*arg2)() = (void (*)()) 0 ;
50306
50307   arg1 = (Dali::Signal< void () > *)jarg1;
50308   arg2 = (void (*)())jarg2;
50309   {
50310     try {
50311       (arg1)->Connect(arg2);
50312     } catch (std::out_of_range& e) {
50313       {
50314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50315       };
50316     } catch (std::exception& e) {
50317       {
50318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50319       };
50320     } catch (Dali::DaliException e) {
50321       {
50322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50323       };
50324     } catch (...) {
50325       {
50326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50327       };
50328     }
50329   }
50330
50331 }
50332
50333
50334 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Disconnect(void * jarg1, void * jarg2) {
50335   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50336   void (*arg2)() = (void (*)()) 0 ;
50337
50338   arg1 = (Dali::Signal< void () > *)jarg1;
50339   arg2 = (void (*)())jarg2;
50340   {
50341     try {
50342       (arg1)->Disconnect(arg2);
50343     } catch (std::out_of_range& e) {
50344       {
50345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50346       };
50347     } catch (std::exception& e) {
50348       {
50349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50350       };
50351     } catch (Dali::DaliException e) {
50352       {
50353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50354       };
50355     } catch (...) {
50356       {
50357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50358       };
50359     }
50360   }
50361
50362 }
50363
50364
50365 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Connect__SWIG_4(void * jarg1, void * jarg2, void * jarg3) {
50366   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50367   Dali::ConnectionTrackerInterface *arg2 = (Dali::ConnectionTrackerInterface *) 0 ;
50368   Dali::FunctorDelegate *arg3 = (Dali::FunctorDelegate *) 0 ;
50369
50370   arg1 = (Dali::Signal< void () > *)jarg1;
50371   arg2 = (Dali::ConnectionTrackerInterface *)jarg2;
50372   arg3 = (Dali::FunctorDelegate *)jarg3;
50373   {
50374     try {
50375       (arg1)->Connect(arg2,arg3);
50376     } catch (std::out_of_range& e) {
50377       {
50378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50379       };
50380     } catch (std::exception& e) {
50381       {
50382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50383       };
50384     } catch (Dali::DaliException e) {
50385       {
50386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50387       };
50388     } catch (...) {
50389       {
50390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50391       };
50392     }
50393   }
50394
50395 }
50396
50397
50398 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VoidSignal_Emit(void * jarg1) {
50399   Dali::Signal< void () > *arg1 = (Dali::Signal< void () > *) 0 ;
50400
50401   arg1 = (Dali::Signal< void () > *)jarg1;
50402   {
50403     try {
50404       (arg1)->Emit();
50405     } catch (std::out_of_range& e) {
50406       {
50407         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50408       };
50409     } catch (std::exception& e) {
50410       {
50411         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50412       };
50413     } catch (Dali::DaliException e) {
50414       {
50415         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50416       };
50417     } catch (...) {
50418       {
50419         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50420       };
50421     }
50422   }
50423
50424 }
50425
50426
50427 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FloatSignal_Empty(void * jarg1) {
50428   unsigned int jresult ;
50429   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50430   bool result;
50431
50432   arg1 = (Dali::Signal< void (float) > *)jarg1;
50433   {
50434     try {
50435       result = (bool)Dali_Signal_Sl_void_Sp_float_SP__Sg__Empty((Dali::Signal< void (float) > const *)arg1);
50436     } catch (std::out_of_range& e) {
50437       {
50438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50439       };
50440     } catch (std::exception& e) {
50441       {
50442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50443       };
50444     } catch (Dali::DaliException e) {
50445       {
50446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50447       };
50448     } catch (...) {
50449       {
50450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50451       };
50452     }
50453   }
50454
50455   jresult = result;
50456   return jresult;
50457 }
50458
50459
50460 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FloatSignal_GetConnectionCount(void * jarg1) {
50461   unsigned long jresult ;
50462   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50463   std::size_t result;
50464
50465   arg1 = (Dali::Signal< void (float) > *)jarg1;
50466   {
50467     try {
50468       result = Dali_Signal_Sl_void_Sp_float_SP__Sg__GetConnectionCount((Dali::Signal< void (float) > const *)arg1);
50469     } catch (std::out_of_range& e) {
50470       {
50471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50472       };
50473     } catch (std::exception& e) {
50474       {
50475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50476       };
50477     } catch (Dali::DaliException e) {
50478       {
50479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50480       };
50481     } catch (...) {
50482       {
50483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50484       };
50485     }
50486   }
50487
50488   jresult = (unsigned long)result;
50489   return jresult;
50490 }
50491
50492
50493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Connect(void * jarg1, void * jarg2) {
50494   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50495   void (*arg2)(float) = (void (*)(float)) 0 ;
50496
50497   arg1 = (Dali::Signal< void (float) > *)jarg1;
50498   arg2 = (void (*)(float))jarg2;
50499   {
50500     try {
50501       Dali_Signal_Sl_void_Sp_float_SP__Sg__Connect(arg1,arg2);
50502     } catch (std::out_of_range& e) {
50503       {
50504         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50505       };
50506     } catch (std::exception& e) {
50507       {
50508         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50509       };
50510     } catch (Dali::DaliException e) {
50511       {
50512         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50513       };
50514     } catch (...) {
50515       {
50516         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50517       };
50518     }
50519   }
50520
50521 }
50522
50523
50524 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Disconnect(void * jarg1, void * jarg2) {
50525   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50526   void (*arg2)(float) = (void (*)(float)) 0 ;
50527
50528   arg1 = (Dali::Signal< void (float) > *)jarg1;
50529   arg2 = (void (*)(float))jarg2;
50530   {
50531     try {
50532       Dali_Signal_Sl_void_Sp_float_SP__Sg__Disconnect(arg1,arg2);
50533     } catch (std::out_of_range& e) {
50534       {
50535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50536       };
50537     } catch (std::exception& e) {
50538       {
50539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50540       };
50541     } catch (Dali::DaliException e) {
50542       {
50543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50544       };
50545     } catch (...) {
50546       {
50547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50548       };
50549     }
50550   }
50551
50552 }
50553
50554
50555 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FloatSignal_Emit(void * jarg1, float jarg2) {
50556   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50557   float arg2 ;
50558
50559   arg1 = (Dali::Signal< void (float) > *)jarg1;
50560   arg2 = (float)jarg2;
50561   {
50562     try {
50563       Dali_Signal_Sl_void_Sp_float_SP__Sg__Emit(arg1,arg2);
50564     } catch (std::out_of_range& e) {
50565       {
50566         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50567       };
50568     } catch (std::exception& e) {
50569       {
50570         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50571       };
50572     } catch (Dali::DaliException e) {
50573       {
50574         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50575       };
50576     } catch (...) {
50577       {
50578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50579       };
50580     }
50581   }
50582
50583 }
50584
50585
50586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FloatSignal() {
50587   void * jresult ;
50588   Dali::Signal< void (float) > *result = 0 ;
50589
50590   {
50591     try {
50592       result = (Dali::Signal< void (float) > *)new Dali::Signal< void (float) >();
50593     } catch (std::out_of_range& e) {
50594       {
50595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50596       };
50597     } catch (std::exception& e) {
50598       {
50599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50600       };
50601     } catch (Dali::DaliException e) {
50602       {
50603         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50604       };
50605     } catch (...) {
50606       {
50607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50608       };
50609     }
50610   }
50611
50612   jresult = (void *)result;
50613   return jresult;
50614 }
50615
50616
50617 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FloatSignal(void * jarg1) {
50618   Dali::Signal< void (float) > *arg1 = (Dali::Signal< void (float) > *) 0 ;
50619
50620   arg1 = (Dali::Signal< void (float) > *)jarg1;
50621   {
50622     try {
50623       delete arg1;
50624     } catch (std::out_of_range& e) {
50625       {
50626         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50627       };
50628     } catch (std::exception& e) {
50629       {
50630         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50631       };
50632     } catch (Dali::DaliException e) {
50633       {
50634         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50635       };
50636     } catch (...) {
50637       {
50638         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50639       };
50640     }
50641   }
50642
50643 }
50644
50645
50646 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Empty(void * jarg1) {
50647   unsigned int jresult ;
50648   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50649   bool result;
50650
50651   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50652   {
50653     try {
50654       result = (bool)Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Empty((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50655     } catch (std::out_of_range& e) {
50656       {
50657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50658       };
50659     } catch (std::exception& e) {
50660       {
50661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50662       };
50663     } catch (Dali::DaliException e) {
50664       {
50665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50666       };
50667     } catch (...) {
50668       {
50669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50670       };
50671     }
50672   }
50673
50674   jresult = result;
50675   return jresult;
50676 }
50677
50678
50679 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_GetConnectionCount(void * jarg1) {
50680   unsigned long jresult ;
50681   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50682   std::size_t result;
50683
50684   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50685   {
50686     try {
50687       result = Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::BaseHandle) > const *)arg1);
50688     } catch (std::out_of_range& e) {
50689       {
50690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50691       };
50692     } catch (std::exception& e) {
50693       {
50694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50695       };
50696     } catch (Dali::DaliException e) {
50697       {
50698         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50699       };
50700     } catch (...) {
50701       {
50702         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50703       };
50704     }
50705   }
50706
50707   jresult = (unsigned long)result;
50708   return jresult;
50709 }
50710
50711
50712 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Connect(void * jarg1, void * jarg2) {
50713   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50714   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50715
50716   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50717   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50718   {
50719     try {
50720       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Connect(arg1,arg2);
50721     } catch (std::out_of_range& e) {
50722       {
50723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50724       };
50725     } catch (std::exception& e) {
50726       {
50727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50728       };
50729     } catch (Dali::DaliException e) {
50730       {
50731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50732       };
50733     } catch (...) {
50734       {
50735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50736       };
50737     }
50738   }
50739
50740 }
50741
50742
50743 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Disconnect(void * jarg1, void * jarg2) {
50744   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50745   void (*arg2)(Dali::BaseHandle) = (void (*)(Dali::BaseHandle)) 0 ;
50746
50747   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50748   arg2 = (void (*)(Dali::BaseHandle))jarg2;
50749   {
50750     try {
50751       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Disconnect(arg1,arg2);
50752     } catch (std::out_of_range& e) {
50753       {
50754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50755       };
50756     } catch (std::exception& e) {
50757       {
50758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50759       };
50760     } catch (Dali::DaliException e) {
50761       {
50762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50763       };
50764     } catch (...) {
50765       {
50766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50767       };
50768     }
50769   }
50770
50771 }
50772
50773
50774 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectCreatedSignal_Emit(void * jarg1, void * jarg2) {
50775   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50776   Dali::BaseHandle arg2 ;
50777   Dali::BaseHandle *argp2 ;
50778
50779   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50780   argp2 = (Dali::BaseHandle *)jarg2;
50781   if (!argp2) {
50782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
50783     return ;
50784   }
50785   arg2 = *argp2;
50786   {
50787     try {
50788       Dali_Signal_Sl_void_Sp_Dali_BaseHandle_SP__Sg__Emit(arg1,arg2);
50789     } catch (std::out_of_range& e) {
50790       {
50791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50792       };
50793     } catch (std::exception& e) {
50794       {
50795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50796       };
50797     } catch (Dali::DaliException e) {
50798       {
50799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50800       };
50801     } catch (...) {
50802       {
50803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50804       };
50805     }
50806   }
50807
50808 }
50809
50810
50811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectCreatedSignal() {
50812   void * jresult ;
50813   Dali::Signal< void (Dali::BaseHandle) > *result = 0 ;
50814
50815   {
50816     try {
50817       result = (Dali::Signal< void (Dali::BaseHandle) > *)new Dali::Signal< void (Dali::BaseHandle) >();
50818     } catch (std::out_of_range& e) {
50819       {
50820         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50821       };
50822     } catch (std::exception& e) {
50823       {
50824         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50825       };
50826     } catch (Dali::DaliException e) {
50827       {
50828         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50829       };
50830     } catch (...) {
50831       {
50832         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50833       };
50834     }
50835   }
50836
50837   jresult = (void *)result;
50838   return jresult;
50839 }
50840
50841
50842 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectCreatedSignal(void * jarg1) {
50843   Dali::Signal< void (Dali::BaseHandle) > *arg1 = (Dali::Signal< void (Dali::BaseHandle) > *) 0 ;
50844
50845   arg1 = (Dali::Signal< void (Dali::BaseHandle) > *)jarg1;
50846   {
50847     try {
50848       delete arg1;
50849     } catch (std::out_of_range& e) {
50850       {
50851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50852       };
50853     } catch (std::exception& e) {
50854       {
50855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50856       };
50857     } catch (Dali::DaliException e) {
50858       {
50859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50860       };
50861     } catch (...) {
50862       {
50863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50864       };
50865     }
50866   }
50867
50868 }
50869
50870
50871 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Empty(void * jarg1) {
50872   unsigned int jresult ;
50873   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50874   bool result;
50875
50876   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50877   {
50878     try {
50879       result = (bool)Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Empty((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50880     } catch (std::out_of_range& e) {
50881       {
50882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50883       };
50884     } catch (std::exception& e) {
50885       {
50886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50887       };
50888     } catch (Dali::DaliException e) {
50889       {
50890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50891       };
50892     } catch (...) {
50893       {
50894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50895       };
50896     }
50897   }
50898
50899   jresult = result;
50900   return jresult;
50901 }
50902
50903
50904 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_GetConnectionCount(void * jarg1) {
50905   unsigned long jresult ;
50906   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50907   std::size_t result;
50908
50909   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50910   {
50911     try {
50912       result = Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::RefObject const *) > const *)arg1);
50913     } catch (std::out_of_range& e) {
50914       {
50915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
50916       };
50917     } catch (std::exception& e) {
50918       {
50919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
50920       };
50921     } catch (Dali::DaliException e) {
50922       {
50923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
50924       };
50925     } catch (...) {
50926       {
50927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
50928       };
50929     }
50930   }
50931
50932   jresult = (unsigned long)result;
50933   return jresult;
50934 }
50935
50936
50937 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Connect(void * jarg1, void * jarg2) {
50938   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50939   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50940
50941   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50942   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50943   {
50944     try {
50945       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Connect(arg1,arg2);
50946     } catch (std::out_of_range& e) {
50947       {
50948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50949       };
50950     } catch (std::exception& e) {
50951       {
50952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50953       };
50954     } catch (Dali::DaliException e) {
50955       {
50956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50957       };
50958     } catch (...) {
50959       {
50960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50961       };
50962     }
50963   }
50964
50965 }
50966
50967
50968 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Disconnect(void * jarg1, void * jarg2) {
50969   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
50970   void (*arg2)(Dali::RefObject const *) = (void (*)(Dali::RefObject const *)) 0 ;
50971
50972   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
50973   arg2 = (void (*)(Dali::RefObject const *))jarg2;
50974   {
50975     try {
50976       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Disconnect(arg1,arg2);
50977     } catch (std::out_of_range& e) {
50978       {
50979         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
50980       };
50981     } catch (std::exception& e) {
50982       {
50983         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
50984       };
50985     } catch (Dali::DaliException e) {
50986       {
50987         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
50988       };
50989     } catch (...) {
50990       {
50991         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
50992       };
50993     }
50994   }
50995
50996 }
50997
50998
50999 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ObjectDestroyedSignal_Emit(void * jarg1, void * jarg2) {
51000   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51001   Dali::RefObject *arg2 = (Dali::RefObject *) 0 ;
51002
51003   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51004   arg2 = (Dali::RefObject *)jarg2;
51005   {
51006     try {
51007       Dali_Signal_Sl_void_Sp_Dali_RefObject_SS_const_Sm__SP__Sg__Emit(arg1,(Dali::RefObject const *)arg2);
51008     } catch (std::out_of_range& e) {
51009       {
51010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51011       };
51012     } catch (std::exception& e) {
51013       {
51014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51015       };
51016     } catch (Dali::DaliException e) {
51017       {
51018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51019       };
51020     } catch (...) {
51021       {
51022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51023       };
51024     }
51025   }
51026
51027 }
51028
51029
51030 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ObjectDestroyedSignal() {
51031   void * jresult ;
51032   Dali::Signal< void (Dali::RefObject const *) > *result = 0 ;
51033
51034   {
51035     try {
51036       result = (Dali::Signal< void (Dali::RefObject const *) > *)new Dali::Signal< void (Dali::RefObject const *) >();
51037     } catch (std::out_of_range& e) {
51038       {
51039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51040       };
51041     } catch (std::exception& e) {
51042       {
51043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51044       };
51045     } catch (Dali::DaliException e) {
51046       {
51047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51048       };
51049     } catch (...) {
51050       {
51051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51052       };
51053     }
51054   }
51055
51056   jresult = (void *)result;
51057   return jresult;
51058 }
51059
51060
51061 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ObjectDestroyedSignal(void * jarg1) {
51062   Dali::Signal< void (Dali::RefObject const *) > *arg1 = (Dali::Signal< void (Dali::RefObject const *) > *) 0 ;
51063
51064   arg1 = (Dali::Signal< void (Dali::RefObject const *) > *)jarg1;
51065   {
51066     try {
51067       delete arg1;
51068     } catch (std::out_of_range& e) {
51069       {
51070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51071       };
51072     } catch (std::exception& e) {
51073       {
51074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51075       };
51076     } catch (Dali::DaliException e) {
51077       {
51078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51079       };
51080     } catch (...) {
51081       {
51082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51083       };
51084     }
51085   }
51086
51087 }
51088
51089
51090 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Empty(void * jarg1) {
51091   unsigned int jresult ;
51092   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51093   bool result;
51094
51095   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51096   {
51097     try {
51098       result = (bool)Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Empty((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51099     } catch (std::out_of_range& e) {
51100       {
51101         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51102       };
51103     } catch (std::exception& e) {
51104       {
51105         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51106       };
51107     } catch (Dali::DaliException e) {
51108       {
51109         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51110       };
51111     } catch (...) {
51112       {
51113         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51114       };
51115     }
51116   }
51117
51118   jresult = result;
51119   return jresult;
51120 }
51121
51122
51123 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_GetConnectionCount(void * jarg1) {
51124   unsigned long jresult ;
51125   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51126   std::size_t result;
51127
51128   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51129   {
51130     try {
51131       result = Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::PropertyNotification &) > const *)arg1);
51132     } catch (std::out_of_range& e) {
51133       {
51134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51135       };
51136     } catch (std::exception& e) {
51137       {
51138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51139       };
51140     } catch (Dali::DaliException e) {
51141       {
51142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51143       };
51144     } catch (...) {
51145       {
51146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51147       };
51148     }
51149   }
51150
51151   jresult = (unsigned long)result;
51152   return jresult;
51153 }
51154
51155
51156 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Connect(void * jarg1, void * jarg2) {
51157   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51158   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51159
51160   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51161   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51162   {
51163     try {
51164       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Connect(arg1,arg2);
51165     } catch (std::out_of_range& e) {
51166       {
51167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51168       };
51169     } catch (std::exception& e) {
51170       {
51171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51172       };
51173     } catch (Dali::DaliException e) {
51174       {
51175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51176       };
51177     } catch (...) {
51178       {
51179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51180       };
51181     }
51182   }
51183
51184 }
51185
51186
51187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Disconnect(void * jarg1, void * jarg2) {
51188   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51189   void (*arg2)(Dali::PropertyNotification &) = (void (*)(Dali::PropertyNotification &)) 0 ;
51190
51191   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51192   arg2 = (void (*)(Dali::PropertyNotification &))jarg2;
51193   {
51194     try {
51195       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Disconnect(arg1,arg2);
51196     } catch (std::out_of_range& e) {
51197       {
51198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51199       };
51200     } catch (std::exception& e) {
51201       {
51202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51203       };
51204     } catch (Dali::DaliException e) {
51205       {
51206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51207       };
51208     } catch (...) {
51209       {
51210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51211       };
51212     }
51213   }
51214
51215 }
51216
51217
51218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PropertyNotifySignal_Emit(void * jarg1, void * jarg2) {
51219   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51220   Dali::PropertyNotification *arg2 = 0 ;
51221
51222   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51223   arg2 = (Dali::PropertyNotification *)jarg2;
51224   if (!arg2) {
51225     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PropertyNotification & type is null", 0);
51226     return ;
51227   }
51228   {
51229     try {
51230       Dali_Signal_Sl_void_Sp_Dali_PropertyNotification_SA__SP__Sg__Emit(arg1,*arg2);
51231     } catch (std::out_of_range& e) {
51232       {
51233         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51234       };
51235     } catch (std::exception& e) {
51236       {
51237         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51238       };
51239     } catch (Dali::DaliException e) {
51240       {
51241         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51242       };
51243     } catch (...) {
51244       {
51245         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51246       };
51247     }
51248   }
51249
51250 }
51251
51252
51253 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PropertyNotifySignal() {
51254   void * jresult ;
51255   Dali::Signal< void (Dali::PropertyNotification &) > *result = 0 ;
51256
51257   {
51258     try {
51259       result = (Dali::Signal< void (Dali::PropertyNotification &) > *)new Dali::Signal< void (Dali::PropertyNotification &) >();
51260     } catch (std::out_of_range& e) {
51261       {
51262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51263       };
51264     } catch (std::exception& e) {
51265       {
51266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51267       };
51268     } catch (Dali::DaliException e) {
51269       {
51270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51271       };
51272     } catch (...) {
51273       {
51274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51275       };
51276     }
51277   }
51278
51279   jresult = (void *)result;
51280   return jresult;
51281 }
51282
51283
51284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PropertyNotifySignal(void * jarg1) {
51285   Dali::Signal< void (Dali::PropertyNotification &) > *arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *) 0 ;
51286
51287   arg1 = (Dali::Signal< void (Dali::PropertyNotification &) > *)jarg1;
51288   {
51289     try {
51290       delete arg1;
51291     } catch (std::out_of_range& e) {
51292       {
51293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51294       };
51295     } catch (std::exception& e) {
51296       {
51297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51298       };
51299     } catch (Dali::DaliException e) {
51300       {
51301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51302       };
51303     } catch (...) {
51304       {
51305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51306       };
51307     }
51308   }
51309
51310 }
51311
51312
51313 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RenderTaskSignal() {
51314   void * jresult ;
51315   Dali::Signal< void (Dali::RenderTask &) > *result = 0 ;
51316
51317   {
51318     try {
51319       result = (Dali::Signal< void (Dali::RenderTask &) > *)new Dali::Signal< void (Dali::RenderTask &) >();
51320     } catch (std::out_of_range& e) {
51321       {
51322         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51323       };
51324     } catch (std::exception& e) {
51325       {
51326         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51327       };
51328     } catch (Dali::DaliException e) {
51329       {
51330         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51331       };
51332     } catch (...) {
51333       {
51334         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51335       };
51336     }
51337   }
51338
51339   jresult = (void *)result;
51340   return jresult;
51341 }
51342
51343
51344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RenderTaskSignal(void * jarg1) {
51345   Dali::Signal< void (Dali::RenderTask &) > *arg1 = (Dali::Signal< void (Dali::RenderTask &) > *) 0 ;
51346
51347   arg1 = (Dali::Signal< void (Dali::RenderTask &) > *)jarg1;
51348   {
51349     try {
51350       delete arg1;
51351     } catch (std::out_of_range& e) {
51352       {
51353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51354       };
51355     } catch (std::exception& e) {
51356       {
51357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51358       };
51359     } catch (Dali::DaliException e) {
51360       {
51361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51362       };
51363     } catch (...) {
51364       {
51365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51366       };
51367     }
51368   }
51369
51370 }
51371
51372
51373 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Empty(void * jarg1) {
51374   unsigned int jresult ;
51375   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51376   bool result;
51377
51378   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51379   {
51380     try {
51381       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);
51382     } catch (std::out_of_range& e) {
51383       {
51384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51385       };
51386     } catch (std::exception& e) {
51387       {
51388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51389       };
51390     } catch (Dali::DaliException e) {
51391       {
51392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51393       };
51394     } catch (...) {
51395       {
51396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51397       };
51398     }
51399   }
51400
51401   jresult = result;
51402   return jresult;
51403 }
51404
51405
51406 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_GetConnectionCount(void * jarg1) {
51407   unsigned long jresult ;
51408   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51409   std::size_t result;
51410
51411   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51412   {
51413     try {
51414       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);
51415     } catch (std::out_of_range& e) {
51416       {
51417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51418       };
51419     } catch (std::exception& e) {
51420       {
51421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51422       };
51423     } catch (Dali::DaliException e) {
51424       {
51425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51426       };
51427     } catch (...) {
51428       {
51429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51430       };
51431     }
51432   }
51433
51434   jresult = (unsigned long)result;
51435   return jresult;
51436 }
51437
51438
51439 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
51440   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51441   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51442
51443   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51444   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51445   {
51446     try {
51447       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51448     } catch (std::out_of_range& e) {
51449       {
51450         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51451       };
51452     } catch (std::exception& e) {
51453       {
51454         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51455       };
51456     } catch (Dali::DaliException e) {
51457       {
51458         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51459       };
51460     } catch (...) {
51461       {
51462         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51463       };
51464     }
51465   }
51466
51467 }
51468
51469
51470 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
51471   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51472   void (*arg2)(Dali::Actor,Dali::LongPressGesture const &) = (void (*)(Dali::Actor,Dali::LongPressGesture const &)) 0 ;
51473
51474   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51475   arg2 = (void (*)(Dali::Actor,Dali::LongPressGesture const &))jarg2;
51476   {
51477     try {
51478       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51479     } catch (std::out_of_range& e) {
51480       {
51481         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51482       };
51483     } catch (std::exception& e) {
51484       {
51485         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51486       };
51487     } catch (Dali::DaliException e) {
51488       {
51489         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51490       };
51491     } catch (...) {
51492       {
51493         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51494       };
51495     }
51496   }
51497
51498 }
51499
51500
51501 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_LongPressGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51502   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51503   Dali::Actor arg2 ;
51504   Dali::LongPressGesture *arg3 = 0 ;
51505   Dali::Actor *argp2 ;
51506
51507   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51508   argp2 = (Dali::Actor *)jarg2;
51509   if (!argp2) {
51510     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51511     return ;
51512   }
51513   arg2 = *argp2;
51514   arg3 = (Dali::LongPressGesture *)jarg3;
51515   if (!arg3) {
51516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
51517     return ;
51518   }
51519   {
51520     try {
51521       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_LongPressGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::LongPressGesture const &)*arg3);
51522     } catch (std::out_of_range& e) {
51523       {
51524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51525       };
51526     } catch (std::exception& e) {
51527       {
51528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51529       };
51530     } catch (Dali::DaliException e) {
51531       {
51532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51533       };
51534     } catch (...) {
51535       {
51536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51537       };
51538     }
51539   }
51540
51541 }
51542
51543
51544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_LongPressGestureDetectedSignal() {
51545   void * jresult ;
51546   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *result = 0 ;
51547
51548   {
51549     try {
51550       result = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) >();
51551     } catch (std::out_of_range& e) {
51552       {
51553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51554       };
51555     } catch (std::exception& e) {
51556       {
51557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51558       };
51559     } catch (Dali::DaliException e) {
51560       {
51561         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51562       };
51563     } catch (...) {
51564       {
51565         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51566       };
51567     }
51568   }
51569
51570   jresult = (void *)result;
51571   return jresult;
51572 }
51573
51574
51575 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_LongPressGestureDetectedSignal(void * jarg1) {
51576   Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *) 0 ;
51577
51578   arg1 = (Dali::Signal< void (Dali::Actor,Dali::LongPressGesture const &) > *)jarg1;
51579   {
51580     try {
51581       delete arg1;
51582     } catch (std::out_of_range& e) {
51583       {
51584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51585       };
51586     } catch (std::exception& e) {
51587       {
51588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51589       };
51590     } catch (Dali::DaliException e) {
51591       {
51592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51593       };
51594     } catch (...) {
51595       {
51596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51597       };
51598     }
51599   }
51600
51601 }
51602
51603
51604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Empty(void * jarg1) {
51605   unsigned int jresult ;
51606   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51607   bool result;
51608
51609   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51610   {
51611     try {
51612       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);
51613     } catch (std::out_of_range& e) {
51614       {
51615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51616       };
51617     } catch (std::exception& e) {
51618       {
51619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51620       };
51621     } catch (Dali::DaliException e) {
51622       {
51623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51624       };
51625     } catch (...) {
51626       {
51627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51628       };
51629     }
51630   }
51631
51632   jresult = result;
51633   return jresult;
51634 }
51635
51636
51637 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_GetConnectionCount(void * jarg1) {
51638   unsigned long jresult ;
51639   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51640   std::size_t result;
51641
51642   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51643   {
51644     try {
51645       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);
51646     } catch (std::out_of_range& e) {
51647       {
51648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51649       };
51650     } catch (std::exception& e) {
51651       {
51652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51653       };
51654     } catch (Dali::DaliException e) {
51655       {
51656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51657       };
51658     } catch (...) {
51659       {
51660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51661       };
51662     }
51663   }
51664
51665   jresult = (unsigned long)result;
51666   return jresult;
51667 }
51668
51669
51670 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Connect(void * jarg1, void * jarg2) {
51671   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51672   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51673
51674   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51675   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51676   {
51677     try {
51678       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51679     } catch (std::out_of_range& e) {
51680       {
51681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51682       };
51683     } catch (std::exception& e) {
51684       {
51685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51686       };
51687     } catch (Dali::DaliException e) {
51688       {
51689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51690       };
51691     } catch (...) {
51692       {
51693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51694       };
51695     }
51696   }
51697
51698 }
51699
51700
51701 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Disconnect(void * jarg1, void * jarg2) {
51702   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51703   bool (*arg2)(Dali::Actor,Dali::TouchData const &) = (bool (*)(Dali::Actor,Dali::TouchData const &)) 0 ;
51704
51705   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51706   arg2 = (bool (*)(Dali::Actor,Dali::TouchData const &))jarg2;
51707   {
51708     try {
51709       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51710     } catch (std::out_of_range& e) {
51711       {
51712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51713       };
51714     } catch (std::exception& e) {
51715       {
51716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51717       };
51718     } catch (Dali::DaliException e) {
51719       {
51720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51721       };
51722     } catch (...) {
51723       {
51724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51725       };
51726     }
51727   }
51728
51729 }
51730
51731
51732 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorTouchDataSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51733   unsigned int jresult ;
51734   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51735   Dali::Actor arg2 ;
51736   Dali::TouchData *arg3 = 0 ;
51737   Dali::Actor *argp2 ;
51738   bool result;
51739
51740   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51741   argp2 = (Dali::Actor *)jarg2;
51742   if (!argp2) {
51743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51744     return 0;
51745   }
51746   arg2 = *argp2;
51747   arg3 = (Dali::TouchData *)jarg3;
51748   if (!arg3) {
51749     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
51750     return 0;
51751   }
51752   {
51753     try {
51754       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TouchData const &)*arg3);
51755     } catch (std::out_of_range& e) {
51756       {
51757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51758       };
51759     } catch (std::exception& e) {
51760       {
51761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51762       };
51763     } catch (Dali::DaliException e) {
51764       {
51765         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51766       };
51767     } catch (...) {
51768       {
51769         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51770       };
51771     }
51772   }
51773
51774   jresult = result;
51775   return jresult;
51776 }
51777
51778
51779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorTouchDataSignal() {
51780   void * jresult ;
51781   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *result = 0 ;
51782
51783   {
51784     try {
51785       result = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) >();
51786     } catch (std::out_of_range& e) {
51787       {
51788         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51789       };
51790     } catch (std::exception& e) {
51791       {
51792         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51793       };
51794     } catch (Dali::DaliException e) {
51795       {
51796         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51797       };
51798     } catch (...) {
51799       {
51800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51801       };
51802     }
51803   }
51804
51805   jresult = (void *)result;
51806   return jresult;
51807 }
51808
51809
51810 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorTouchDataSignal(void * jarg1) {
51811   Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *) 0 ;
51812
51813   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::TouchData const &) > *)jarg1;
51814   {
51815     try {
51816       delete arg1;
51817     } catch (std::out_of_range& e) {
51818       {
51819         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51820       };
51821     } catch (std::exception& e) {
51822       {
51823         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51824       };
51825     } catch (Dali::DaliException e) {
51826       {
51827         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51828       };
51829     } catch (...) {
51830       {
51831         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51832       };
51833     }
51834   }
51835
51836 }
51837
51838
51839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Empty(void * jarg1) {
51840   unsigned int jresult ;
51841   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51842   bool result;
51843
51844   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51845   {
51846     try {
51847       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);
51848     } catch (std::out_of_range& e) {
51849       {
51850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51851       };
51852     } catch (std::exception& e) {
51853       {
51854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51855       };
51856     } catch (Dali::DaliException e) {
51857       {
51858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51859       };
51860     } catch (...) {
51861       {
51862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51863       };
51864     }
51865   }
51866
51867   jresult = result;
51868   return jresult;
51869 }
51870
51871
51872 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorHoverSignal_GetConnectionCount(void * jarg1) {
51873   unsigned long jresult ;
51874   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51875   std::size_t result;
51876
51877   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51878   {
51879     try {
51880       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);
51881     } catch (std::out_of_range& e) {
51882       {
51883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51884       };
51885     } catch (std::exception& e) {
51886       {
51887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51888       };
51889     } catch (Dali::DaliException e) {
51890       {
51891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
51892       };
51893     } catch (...) {
51894       {
51895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
51896       };
51897     }
51898   }
51899
51900   jresult = (unsigned long)result;
51901   return jresult;
51902 }
51903
51904
51905 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Connect(void * jarg1, void * jarg2) {
51906   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51907   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51908
51909   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51910   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51911   {
51912     try {
51913       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
51914     } catch (std::out_of_range& e) {
51915       {
51916         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51917       };
51918     } catch (std::exception& e) {
51919       {
51920         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51921       };
51922     } catch (Dali::DaliException e) {
51923       {
51924         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51925       };
51926     } catch (...) {
51927       {
51928         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51929       };
51930     }
51931   }
51932
51933 }
51934
51935
51936 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Disconnect(void * jarg1, void * jarg2) {
51937   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51938   bool (*arg2)(Dali::Actor,Dali::HoverEvent const &) = (bool (*)(Dali::Actor,Dali::HoverEvent const &)) 0 ;
51939
51940   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51941   arg2 = (bool (*)(Dali::Actor,Dali::HoverEvent const &))jarg2;
51942   {
51943     try {
51944       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
51945     } catch (std::out_of_range& e) {
51946       {
51947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
51948       };
51949     } catch (std::exception& e) {
51950       {
51951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
51952       };
51953     } catch (Dali::DaliException e) {
51954       {
51955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
51956       };
51957     } catch (...) {
51958       {
51959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
51960       };
51961     }
51962   }
51963
51964 }
51965
51966
51967 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorHoverSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
51968   unsigned int jresult ;
51969   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
51970   Dali::Actor arg2 ;
51971   Dali::HoverEvent *arg3 = 0 ;
51972   Dali::Actor *argp2 ;
51973   bool result;
51974
51975   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
51976   argp2 = (Dali::Actor *)jarg2;
51977   if (!argp2) {
51978     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
51979     return 0;
51980   }
51981   arg2 = *argp2;
51982   arg3 = (Dali::HoverEvent *)jarg3;
51983   if (!arg3) {
51984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
51985     return 0;
51986   }
51987   {
51988     try {
51989       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_HoverEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::HoverEvent const &)*arg3);
51990     } catch (std::out_of_range& e) {
51991       {
51992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
51993       };
51994     } catch (std::exception& e) {
51995       {
51996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
51997       };
51998     } catch (Dali::DaliException e) {
51999       {
52000         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52001       };
52002     } catch (...) {
52003       {
52004         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52005       };
52006     }
52007   }
52008
52009   jresult = result;
52010   return jresult;
52011 }
52012
52013
52014 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorHoverSignal() {
52015   void * jresult ;
52016   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *result = 0 ;
52017
52018   {
52019     try {
52020       result = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) >();
52021     } catch (std::out_of_range& e) {
52022       {
52023         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52024       };
52025     } catch (std::exception& e) {
52026       {
52027         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52028       };
52029     } catch (Dali::DaliException e) {
52030       {
52031         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52032       };
52033     } catch (...) {
52034       {
52035         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52036       };
52037     }
52038   }
52039
52040   jresult = (void *)result;
52041   return jresult;
52042 }
52043
52044
52045 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorHoverSignal(void * jarg1) {
52046   Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *) 0 ;
52047
52048   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::HoverEvent const &) > *)jarg1;
52049   {
52050     try {
52051       delete arg1;
52052     } catch (std::out_of_range& e) {
52053       {
52054         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52055       };
52056     } catch (std::exception& e) {
52057       {
52058         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52059       };
52060     } catch (Dali::DaliException e) {
52061       {
52062         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52063       };
52064     } catch (...) {
52065       {
52066         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52067       };
52068     }
52069   }
52070
52071 }
52072
52073
52074 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Empty(void * jarg1) {
52075   unsigned int jresult ;
52076   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52077   bool result;
52078
52079   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52080   {
52081     try {
52082       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);
52083     } catch (std::out_of_range& e) {
52084       {
52085         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52086       };
52087     } catch (std::exception& e) {
52088       {
52089         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52090       };
52091     } catch (Dali::DaliException e) {
52092       {
52093         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52094       };
52095     } catch (...) {
52096       {
52097         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52098       };
52099     }
52100   }
52101
52102   jresult = result;
52103   return jresult;
52104 }
52105
52106
52107 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorWheelSignal_GetConnectionCount(void * jarg1) {
52108   unsigned long jresult ;
52109   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52110   std::size_t result;
52111
52112   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52113   {
52114     try {
52115       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);
52116     } catch (std::out_of_range& e) {
52117       {
52118         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52119       };
52120     } catch (std::exception& e) {
52121       {
52122         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52123       };
52124     } catch (Dali::DaliException e) {
52125       {
52126         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52127       };
52128     } catch (...) {
52129       {
52130         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52131       };
52132     }
52133   }
52134
52135   jresult = (unsigned long)result;
52136   return jresult;
52137 }
52138
52139
52140 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Connect(void * jarg1, void * jarg2) {
52141   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52142   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52143
52144   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52145   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52146   {
52147     try {
52148       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52149     } catch (std::out_of_range& e) {
52150       {
52151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52152       };
52153     } catch (std::exception& e) {
52154       {
52155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52156       };
52157     } catch (Dali::DaliException e) {
52158       {
52159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52160       };
52161     } catch (...) {
52162       {
52163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52164       };
52165     }
52166   }
52167
52168 }
52169
52170
52171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Disconnect(void * jarg1, void * jarg2) {
52172   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52173   bool (*arg2)(Dali::Actor,Dali::WheelEvent const &) = (bool (*)(Dali::Actor,Dali::WheelEvent const &)) 0 ;
52174
52175   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52176   arg2 = (bool (*)(Dali::Actor,Dali::WheelEvent const &))jarg2;
52177   {
52178     try {
52179       Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52180     } catch (std::out_of_range& e) {
52181       {
52182         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52183       };
52184     } catch (std::exception& e) {
52185       {
52186         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52187       };
52188     } catch (Dali::DaliException e) {
52189       {
52190         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52191       };
52192     } catch (...) {
52193       {
52194         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52195       };
52196     }
52197   }
52198
52199 }
52200
52201
52202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorWheelSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
52203   unsigned int jresult ;
52204   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52205   Dali::Actor arg2 ;
52206   Dali::WheelEvent *arg3 = 0 ;
52207   Dali::Actor *argp2 ;
52208   bool result;
52209
52210   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52211   argp2 = (Dali::Actor *)jarg2;
52212   if (!argp2) {
52213     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52214     return 0;
52215   }
52216   arg2 = *argp2;
52217   arg3 = (Dali::WheelEvent *)jarg3;
52218   if (!arg3) {
52219     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
52220     return 0;
52221   }
52222   {
52223     try {
52224       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Actor_Sc_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::WheelEvent const &)*arg3);
52225     } catch (std::out_of_range& e) {
52226       {
52227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52228       };
52229     } catch (std::exception& e) {
52230       {
52231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52232       };
52233     } catch (Dali::DaliException e) {
52234       {
52235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52236       };
52237     } catch (...) {
52238       {
52239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52240       };
52241     }
52242   }
52243
52244   jresult = result;
52245   return jresult;
52246 }
52247
52248
52249 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorWheelSignal() {
52250   void * jresult ;
52251   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *result = 0 ;
52252
52253   {
52254     try {
52255       result = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)new Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) >();
52256     } catch (std::out_of_range& e) {
52257       {
52258         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52259       };
52260     } catch (std::exception& e) {
52261       {
52262         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52263       };
52264     } catch (Dali::DaliException e) {
52265       {
52266         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52267       };
52268     } catch (...) {
52269       {
52270         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52271       };
52272     }
52273   }
52274
52275   jresult = (void *)result;
52276   return jresult;
52277 }
52278
52279
52280 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorWheelSignal(void * jarg1) {
52281   Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *) 0 ;
52282
52283   arg1 = (Dali::Signal< bool (Dali::Actor,Dali::WheelEvent const &) > *)jarg1;
52284   {
52285     try {
52286       delete arg1;
52287     } catch (std::out_of_range& e) {
52288       {
52289         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52290       };
52291     } catch (std::exception& e) {
52292       {
52293         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52294       };
52295     } catch (Dali::DaliException e) {
52296       {
52297         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52298       };
52299     } catch (...) {
52300       {
52301         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52302       };
52303     }
52304   }
52305
52306 }
52307
52308
52309 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ActorSignal_Empty(void * jarg1) {
52310   unsigned int jresult ;
52311   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52312   bool result;
52313
52314   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52315   {
52316     try {
52317       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor) > const *)arg1);
52318     } catch (std::out_of_range& e) {
52319       {
52320         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52321       };
52322     } catch (std::exception& e) {
52323       {
52324         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52325       };
52326     } catch (Dali::DaliException e) {
52327       {
52328         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52329       };
52330     } catch (...) {
52331       {
52332         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52333       };
52334     }
52335   }
52336
52337   jresult = result;
52338   return jresult;
52339 }
52340
52341
52342 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorSignal_GetConnectionCount(void * jarg1) {
52343   unsigned long jresult ;
52344   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52345   std::size_t result;
52346
52347   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52348   {
52349     try {
52350       result = Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor) > const *)arg1);
52351     } catch (std::out_of_range& e) {
52352       {
52353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52354       };
52355     } catch (std::exception& e) {
52356       {
52357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52358       };
52359     } catch (Dali::DaliException e) {
52360       {
52361         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52362       };
52363     } catch (...) {
52364       {
52365         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52366       };
52367     }
52368   }
52369
52370   jresult = (unsigned long)result;
52371   return jresult;
52372 }
52373
52374
52375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Connect(void * jarg1, void * jarg2) {
52376   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52377   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52378
52379   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52380   arg2 = (void (*)(Dali::Actor))jarg2;
52381   {
52382     try {
52383       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Connect(arg1,arg2);
52384     } catch (std::out_of_range& e) {
52385       {
52386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52387       };
52388     } catch (std::exception& e) {
52389       {
52390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52391       };
52392     } catch (Dali::DaliException e) {
52393       {
52394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52395       };
52396     } catch (...) {
52397       {
52398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52399       };
52400     }
52401   }
52402
52403 }
52404
52405
52406 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Disconnect(void * jarg1, void * jarg2) {
52407   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52408   void (*arg2)(Dali::Actor) = (void (*)(Dali::Actor)) 0 ;
52409
52410   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52411   arg2 = (void (*)(Dali::Actor))jarg2;
52412   {
52413     try {
52414       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
52415     } catch (std::out_of_range& e) {
52416       {
52417         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52418       };
52419     } catch (std::exception& e) {
52420       {
52421         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52422       };
52423     } catch (Dali::DaliException e) {
52424       {
52425         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52426       };
52427     } catch (...) {
52428       {
52429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52430       };
52431     }
52432   }
52433
52434 }
52435
52436
52437 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorSignal_Emit(void * jarg1, void * jarg2) {
52438   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52439   Dali::Actor arg2 ;
52440   Dali::Actor *argp2 ;
52441
52442   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52443   argp2 = (Dali::Actor *)jarg2;
52444   if (!argp2) {
52445     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
52446     return ;
52447   }
52448   arg2 = *argp2;
52449   {
52450     try {
52451       Dali_Signal_Sl_void_Sp_Dali_Actor_SP__Sg__Emit(arg1,arg2);
52452     } catch (std::out_of_range& e) {
52453       {
52454         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52455       };
52456     } catch (std::exception& e) {
52457       {
52458         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52459       };
52460     } catch (Dali::DaliException e) {
52461       {
52462         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52463       };
52464     } catch (...) {
52465       {
52466         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52467       };
52468     }
52469   }
52470
52471 }
52472
52473
52474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorSignal() {
52475   void * jresult ;
52476   Dali::Signal< void (Dali::Actor) > *result = 0 ;
52477
52478   {
52479     try {
52480       result = (Dali::Signal< void (Dali::Actor) > *)new Dali::Signal< void (Dali::Actor) >();
52481     } catch (std::out_of_range& e) {
52482       {
52483         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52484       };
52485     } catch (std::exception& e) {
52486       {
52487         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52488       };
52489     } catch (Dali::DaliException e) {
52490       {
52491         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52492       };
52493     } catch (...) {
52494       {
52495         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52496       };
52497     }
52498   }
52499
52500   jresult = (void *)result;
52501   return jresult;
52502 }
52503
52504
52505 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorSignal(void * jarg1) {
52506   Dali::Signal< void (Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor) > *) 0 ;
52507
52508   arg1 = (Dali::Signal< void (Dali::Actor) > *)jarg1;
52509   {
52510     try {
52511       delete arg1;
52512     } catch (std::out_of_range& e) {
52513       {
52514         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52515       };
52516     } catch (std::exception& e) {
52517       {
52518         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52519       };
52520     } catch (Dali::DaliException e) {
52521       {
52522         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52523       };
52524     } catch (...) {
52525       {
52526         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52527       };
52528     }
52529   }
52530
52531 }
52532
52533
52534 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyEventSignal_Empty(void * jarg1) {
52535   unsigned int jresult ;
52536   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52537   bool result;
52538
52539   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52540   {
52541     try {
52542       result = (bool)Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52543     } catch (std::out_of_range& e) {
52544       {
52545         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52546       };
52547     } catch (std::exception& e) {
52548       {
52549         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52550       };
52551     } catch (Dali::DaliException e) {
52552       {
52553         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52554       };
52555     } catch (...) {
52556       {
52557         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52558       };
52559     }
52560   }
52561
52562   jresult = result;
52563   return jresult;
52564 }
52565
52566
52567 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyEventSignal_GetConnectionCount(void * jarg1) {
52568   unsigned long jresult ;
52569   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52570   std::size_t result;
52571
52572   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52573   {
52574     try {
52575       result = Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::KeyEvent const &) > const *)arg1);
52576     } catch (std::out_of_range& e) {
52577       {
52578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52579       };
52580     } catch (std::exception& e) {
52581       {
52582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52583       };
52584     } catch (Dali::DaliException e) {
52585       {
52586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52587       };
52588     } catch (...) {
52589       {
52590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52591       };
52592     }
52593   }
52594
52595   jresult = (unsigned long)result;
52596   return jresult;
52597 }
52598
52599
52600 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Connect(void * jarg1, void * jarg2) {
52601   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52602   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52603
52604   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52605   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52606   {
52607     try {
52608       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52609     } catch (std::out_of_range& e) {
52610       {
52611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52612       };
52613     } catch (std::exception& e) {
52614       {
52615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52616       };
52617     } catch (Dali::DaliException e) {
52618       {
52619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52620       };
52621     } catch (...) {
52622       {
52623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52624       };
52625     }
52626   }
52627
52628 }
52629
52630
52631 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Disconnect(void * jarg1, void * jarg2) {
52632   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52633   void (*arg2)(Dali::KeyEvent const &) = (void (*)(Dali::KeyEvent const &)) 0 ;
52634
52635   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52636   arg2 = (void (*)(Dali::KeyEvent const &))jarg2;
52637   {
52638     try {
52639       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52640     } catch (std::out_of_range& e) {
52641       {
52642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52643       };
52644     } catch (std::exception& e) {
52645       {
52646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52647       };
52648     } catch (Dali::DaliException e) {
52649       {
52650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52651       };
52652     } catch (...) {
52653       {
52654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52655       };
52656     }
52657   }
52658
52659 }
52660
52661
52662 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyEventSignal_Emit(void * jarg1, void * jarg2) {
52663   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52664   Dali::KeyEvent *arg2 = 0 ;
52665
52666   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52667   arg2 = (Dali::KeyEvent *)jarg2;
52668   if (!arg2) {
52669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
52670     return ;
52671   }
52672   {
52673     try {
52674       Dali_Signal_Sl_void_Sp_Dali_KeyEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::KeyEvent const &)*arg2);
52675     } catch (std::out_of_range& e) {
52676       {
52677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52678       };
52679     } catch (std::exception& e) {
52680       {
52681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52682       };
52683     } catch (Dali::DaliException e) {
52684       {
52685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52686       };
52687     } catch (...) {
52688       {
52689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52690       };
52691     }
52692   }
52693
52694 }
52695
52696
52697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyEventSignal() {
52698   void * jresult ;
52699   Dali::Signal< void (Dali::KeyEvent const &) > *result = 0 ;
52700
52701   {
52702     try {
52703       result = (Dali::Signal< void (Dali::KeyEvent const &) > *)new Dali::Signal< void (Dali::KeyEvent const &) >();
52704     } catch (std::out_of_range& e) {
52705       {
52706         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52707       };
52708     } catch (std::exception& e) {
52709       {
52710         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52711       };
52712     } catch (Dali::DaliException e) {
52713       {
52714         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52715       };
52716     } catch (...) {
52717       {
52718         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52719       };
52720     }
52721   }
52722
52723   jresult = (void *)result;
52724   return jresult;
52725 }
52726
52727
52728 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyEventSignal(void * jarg1) {
52729   Dali::Signal< void (Dali::KeyEvent const &) > *arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *) 0 ;
52730
52731   arg1 = (Dali::Signal< void (Dali::KeyEvent const &) > *)jarg1;
52732   {
52733     try {
52734       delete arg1;
52735     } catch (std::out_of_range& e) {
52736       {
52737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52738       };
52739     } catch (std::exception& e) {
52740       {
52741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52742       };
52743     } catch (Dali::DaliException e) {
52744       {
52745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52746       };
52747     } catch (...) {
52748       {
52749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52750       };
52751     }
52752   }
52753
52754 }
52755
52756
52757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TouchSignal_Empty(void * jarg1) {
52758   unsigned int jresult ;
52759   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52760   bool result;
52761
52762   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52763   {
52764     try {
52765       result = (bool)Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52766     } catch (std::out_of_range& e) {
52767       {
52768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52769       };
52770     } catch (std::exception& e) {
52771       {
52772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52773       };
52774     } catch (Dali::DaliException e) {
52775       {
52776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52777       };
52778     } catch (...) {
52779       {
52780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52781       };
52782     }
52783   }
52784
52785   jresult = result;
52786   return jresult;
52787 }
52788
52789
52790 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TouchSignal_GetConnectionCount(void * jarg1) {
52791   unsigned long jresult ;
52792   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52793   std::size_t result;
52794
52795   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52796   {
52797     try {
52798       result = Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::TouchData const &) > const *)arg1);
52799     } catch (std::out_of_range& e) {
52800       {
52801         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52802       };
52803     } catch (std::exception& e) {
52804       {
52805         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52806       };
52807     } catch (Dali::DaliException e) {
52808       {
52809         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52810       };
52811     } catch (...) {
52812       {
52813         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52814       };
52815     }
52816   }
52817
52818   jresult = (unsigned long)result;
52819   return jresult;
52820 }
52821
52822
52823 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Connect(void * jarg1, void * jarg2) {
52824   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52825   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52826
52827   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52828   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52829   {
52830     try {
52831       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Connect(arg1,arg2);
52832     } catch (std::out_of_range& e) {
52833       {
52834         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52835       };
52836     } catch (std::exception& e) {
52837       {
52838         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52839       };
52840     } catch (Dali::DaliException e) {
52841       {
52842         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52843       };
52844     } catch (...) {
52845       {
52846         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52847       };
52848     }
52849   }
52850
52851 }
52852
52853
52854 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Disconnect(void * jarg1, void * jarg2) {
52855   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52856   void (*arg2)(Dali::TouchData const &) = (void (*)(Dali::TouchData const &)) 0 ;
52857
52858   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52859   arg2 = (void (*)(Dali::TouchData const &))jarg2;
52860   {
52861     try {
52862       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
52863     } catch (std::out_of_range& e) {
52864       {
52865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52866       };
52867     } catch (std::exception& e) {
52868       {
52869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52870       };
52871     } catch (Dali::DaliException e) {
52872       {
52873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52874       };
52875     } catch (...) {
52876       {
52877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52878       };
52879     }
52880   }
52881
52882 }
52883
52884
52885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TouchSignal_Emit(void * jarg1, void * jarg2) {
52886   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52887   Dali::TouchData *arg2 = 0 ;
52888
52889   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52890   arg2 = (Dali::TouchData *)jarg2;
52891   if (!arg2) {
52892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchData const & type is null", 0);
52893     return ;
52894   }
52895   {
52896     try {
52897       Dali_Signal_Sl_void_Sp_Dali_TouchData_SS_const_SA__SP__Sg__Emit(arg1,(Dali::TouchData const &)*arg2);
52898     } catch (std::out_of_range& e) {
52899       {
52900         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52901       };
52902     } catch (std::exception& e) {
52903       {
52904         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52905       };
52906     } catch (Dali::DaliException e) {
52907       {
52908         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52909       };
52910     } catch (...) {
52911       {
52912         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52913       };
52914     }
52915   }
52916
52917 }
52918
52919
52920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TouchSignal() {
52921   void * jresult ;
52922   Dali::Signal< void (Dali::TouchData const &) > *result = 0 ;
52923
52924   {
52925     try {
52926       result = (Dali::Signal< void (Dali::TouchData const &) > *)new Dali::Signal< void (Dali::TouchData const &) >();
52927     } catch (std::out_of_range& e) {
52928       {
52929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52930       };
52931     } catch (std::exception& e) {
52932       {
52933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52934       };
52935     } catch (Dali::DaliException e) {
52936       {
52937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
52938       };
52939     } catch (...) {
52940       {
52941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
52942       };
52943     }
52944   }
52945
52946   jresult = (void *)result;
52947   return jresult;
52948 }
52949
52950
52951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TouchSignal(void * jarg1) {
52952   Dali::Signal< void (Dali::TouchData const &) > *arg1 = (Dali::Signal< void (Dali::TouchData const &) > *) 0 ;
52953
52954   arg1 = (Dali::Signal< void (Dali::TouchData const &) > *)jarg1;
52955   {
52956     try {
52957       delete arg1;
52958     } catch (std::out_of_range& e) {
52959       {
52960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
52961       };
52962     } catch (std::exception& e) {
52963       {
52964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
52965       };
52966     } catch (Dali::DaliException e) {
52967       {
52968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
52969       };
52970     } catch (...) {
52971       {
52972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
52973       };
52974     }
52975   }
52976
52977 }
52978
52979
52980 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StageWheelSignal_Empty(void * jarg1) {
52981   unsigned int jresult ;
52982   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
52983   bool result;
52984
52985   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
52986   {
52987     try {
52988       result = (bool)Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
52989     } catch (std::out_of_range& e) {
52990       {
52991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
52992       };
52993     } catch (std::exception& e) {
52994       {
52995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
52996       };
52997     } catch (Dali::DaliException e) {
52998       {
52999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53000       };
53001     } catch (...) {
53002       {
53003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53004       };
53005     }
53006   }
53007
53008   jresult = result;
53009   return jresult;
53010 }
53011
53012
53013 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StageWheelSignal_GetConnectionCount(void * jarg1) {
53014   unsigned long jresult ;
53015   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53016   std::size_t result;
53017
53018   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53019   {
53020     try {
53021       result = Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::WheelEvent const &) > const *)arg1);
53022     } catch (std::out_of_range& e) {
53023       {
53024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53025       };
53026     } catch (std::exception& e) {
53027       {
53028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53029       };
53030     } catch (Dali::DaliException e) {
53031       {
53032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53033       };
53034     } catch (...) {
53035       {
53036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53037       };
53038     }
53039   }
53040
53041   jresult = (unsigned long)result;
53042   return jresult;
53043 }
53044
53045
53046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Connect(void * jarg1, void * jarg2) {
53047   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53048   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53049
53050   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53051   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53052   {
53053     try {
53054       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53055     } catch (std::out_of_range& e) {
53056       {
53057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53058       };
53059     } catch (std::exception& e) {
53060       {
53061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53062       };
53063     } catch (Dali::DaliException e) {
53064       {
53065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53066       };
53067     } catch (...) {
53068       {
53069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53070       };
53071     }
53072   }
53073
53074 }
53075
53076
53077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Disconnect(void * jarg1, void * jarg2) {
53078   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53079   void (*arg2)(Dali::WheelEvent const &) = (void (*)(Dali::WheelEvent const &)) 0 ;
53080
53081   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53082   arg2 = (void (*)(Dali::WheelEvent const &))jarg2;
53083   {
53084     try {
53085       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53086     } catch (std::out_of_range& e) {
53087       {
53088         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53089       };
53090     } catch (std::exception& e) {
53091       {
53092         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53093       };
53094     } catch (Dali::DaliException e) {
53095       {
53096         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53097       };
53098     } catch (...) {
53099       {
53100         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53101       };
53102     }
53103   }
53104
53105 }
53106
53107
53108 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StageWheelSignal_Emit(void * jarg1, void * jarg2) {
53109   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53110   Dali::WheelEvent *arg2 = 0 ;
53111
53112   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53113   arg2 = (Dali::WheelEvent *)jarg2;
53114   if (!arg2) {
53115     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
53116     return ;
53117   }
53118   {
53119     try {
53120       Dali_Signal_Sl_void_Sp_Dali_WheelEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::WheelEvent const &)*arg2);
53121     } catch (std::out_of_range& e) {
53122       {
53123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53124       };
53125     } catch (std::exception& e) {
53126       {
53127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53128       };
53129     } catch (Dali::DaliException e) {
53130       {
53131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53132       };
53133     } catch (...) {
53134       {
53135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53136       };
53137     }
53138   }
53139
53140 }
53141
53142
53143 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StageWheelSignal() {
53144   void * jresult ;
53145   Dali::Signal< void (Dali::WheelEvent const &) > *result = 0 ;
53146
53147   {
53148     try {
53149       result = (Dali::Signal< void (Dali::WheelEvent const &) > *)new Dali::Signal< void (Dali::WheelEvent const &) >();
53150     } catch (std::out_of_range& e) {
53151       {
53152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53153       };
53154     } catch (std::exception& e) {
53155       {
53156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53157       };
53158     } catch (Dali::DaliException e) {
53159       {
53160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53161       };
53162     } catch (...) {
53163       {
53164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53165       };
53166     }
53167   }
53168
53169   jresult = (void *)result;
53170   return jresult;
53171 }
53172
53173
53174 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StageWheelSignal(void * jarg1) {
53175   Dali::Signal< void (Dali::WheelEvent const &) > *arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *) 0 ;
53176
53177   arg1 = (Dali::Signal< void (Dali::WheelEvent const &) > *)jarg1;
53178   {
53179     try {
53180       delete arg1;
53181     } catch (std::out_of_range& e) {
53182       {
53183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53184       };
53185     } catch (std::exception& e) {
53186       {
53187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53188       };
53189     } catch (Dali::DaliException e) {
53190       {
53191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53192       };
53193     } catch (...) {
53194       {
53195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53196       };
53197     }
53198   }
53199
53200 }
53201
53202
53203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_0() {
53204   void * jresult ;
53205   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53206
53207   {
53208     try {
53209       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >();
53210     } catch (std::out_of_range& e) {
53211       {
53212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53213       };
53214     } catch (std::exception& e) {
53215       {
53216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53217       };
53218     } catch (Dali::DaliException e) {
53219       {
53220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53221       };
53222     } catch (...) {
53223       {
53224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53225       };
53226     }
53227   }
53228
53229   jresult = (void *)result;
53230   return jresult;
53231 }
53232
53233
53234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_1(void * jarg1, void * jarg2) {
53235   void * jresult ;
53236   Dali::Radian arg1 ;
53237   Dali::Radian arg2 ;
53238   Dali::Radian *argp1 ;
53239   Dali::Radian *argp2 ;
53240   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53241
53242   argp1 = (Dali::Radian *)jarg1;
53243   if (!argp1) {
53244     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53245     return 0;
53246   }
53247   arg1 = *argp1;
53248   argp2 = (Dali::Radian *)jarg2;
53249   if (!argp2) {
53250     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
53251     return 0;
53252   }
53253   arg2 = *argp2;
53254   {
53255     try {
53256       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >(arg1,arg2);
53257     } catch (std::out_of_range& e) {
53258       {
53259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53260       };
53261     } catch (std::exception& e) {
53262       {
53263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53264       };
53265     } catch (Dali::DaliException e) {
53266       {
53267         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53268       };
53269     } catch (...) {
53270       {
53271         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53272       };
53273     }
53274   }
53275
53276   jresult = (void *)result;
53277   return jresult;
53278 }
53279
53280
53281 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AngleThresholdPair__SWIG_2(void * jarg1) {
53282   void * jresult ;
53283   std::pair< Dali::Radian,Dali::Radian > *arg1 = 0 ;
53284   std::pair< Dali::Radian,Dali::Radian > *result = 0 ;
53285
53286   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53287   if (!arg1) {
53288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< Dali::Radian,Dali::Radian > const & type is null", 0);
53289     return 0;
53290   }
53291   {
53292     try {
53293       result = (std::pair< Dali::Radian,Dali::Radian > *)new std::pair< Dali::Radian,Dali::Radian >((std::pair< Dali::Radian,Dali::Radian > const &)*arg1);
53294     } catch (std::out_of_range& e) {
53295       {
53296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53297       };
53298     } catch (std::exception& e) {
53299       {
53300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53301       };
53302     } catch (Dali::DaliException e) {
53303       {
53304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53305       };
53306     } catch (...) {
53307       {
53308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53309       };
53310     }
53311   }
53312
53313   jresult = (void *)result;
53314   return jresult;
53315 }
53316
53317
53318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_set(void * jarg1, void * jarg2) {
53319   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53320   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53321
53322   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53323   arg2 = (Dali::Radian *)jarg2;
53324   if (arg1) (arg1)->first = *arg2;
53325 }
53326
53327
53328 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_first_get(void * jarg1) {
53329   void * jresult ;
53330   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53331   Dali::Radian *result = 0 ;
53332
53333   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53334   result = (Dali::Radian *)& ((arg1)->first);
53335   jresult = (void *)result;
53336   return jresult;
53337 }
53338
53339
53340 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_set(void * jarg1, void * jarg2) {
53341   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53342   Dali::Radian *arg2 = (Dali::Radian *) 0 ;
53343
53344   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53345   arg2 = (Dali::Radian *)jarg2;
53346   if (arg1) (arg1)->second = *arg2;
53347 }
53348
53349
53350 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AngleThresholdPair_second_get(void * jarg1) {
53351   void * jresult ;
53352   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53353   Dali::Radian *result = 0 ;
53354
53355   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53356   result = (Dali::Radian *)& ((arg1)->second);
53357   jresult = (void *)result;
53358   return jresult;
53359 }
53360
53361
53362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AngleThresholdPair(void * jarg1) {
53363   std::pair< Dali::Radian,Dali::Radian > *arg1 = (std::pair< Dali::Radian,Dali::Radian > *) 0 ;
53364
53365   arg1 = (std::pair< Dali::Radian,Dali::Radian > *)jarg1;
53366   {
53367     try {
53368       delete arg1;
53369     } catch (std::out_of_range& e) {
53370       {
53371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53372       };
53373     } catch (std::exception& e) {
53374       {
53375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53376       };
53377     } catch (Dali::DaliException e) {
53378       {
53379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53380       };
53381     } catch (...) {
53382       {
53383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53384       };
53385     }
53386   }
53387
53388 }
53389
53390
53391 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Empty(void * jarg1) {
53392   unsigned int jresult ;
53393   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53394   bool result;
53395
53396   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53397   {
53398     try {
53399       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);
53400     } catch (std::out_of_range& e) {
53401       {
53402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53403       };
53404     } catch (std::exception& e) {
53405       {
53406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53407       };
53408     } catch (Dali::DaliException e) {
53409       {
53410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53411       };
53412     } catch (...) {
53413       {
53414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53415       };
53416     }
53417   }
53418
53419   jresult = result;
53420   return jresult;
53421 }
53422
53423
53424 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53425   unsigned long jresult ;
53426   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53427   std::size_t result;
53428
53429   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53430   {
53431     try {
53432       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);
53433     } catch (std::out_of_range& e) {
53434       {
53435         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53436       };
53437     } catch (std::exception& e) {
53438       {
53439         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53440       };
53441     } catch (Dali::DaliException e) {
53442       {
53443         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53444       };
53445     } catch (...) {
53446       {
53447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53448       };
53449     }
53450   }
53451
53452   jresult = (unsigned long)result;
53453   return jresult;
53454 }
53455
53456
53457 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53458   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53459   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53460
53461   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53462   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53463   {
53464     try {
53465       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53466     } catch (std::out_of_range& e) {
53467       {
53468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53469       };
53470     } catch (std::exception& e) {
53471       {
53472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53473       };
53474     } catch (Dali::DaliException e) {
53475       {
53476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53477       };
53478     } catch (...) {
53479       {
53480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53481       };
53482     }
53483   }
53484
53485 }
53486
53487
53488 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53489   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53490   void (*arg2)(Dali::Actor,Dali::PanGesture const &) = (void (*)(Dali::Actor,Dali::PanGesture const &)) 0 ;
53491
53492   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53493   arg2 = (void (*)(Dali::Actor,Dali::PanGesture const &))jarg2;
53494   {
53495     try {
53496       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53497     } catch (std::out_of_range& e) {
53498       {
53499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53500       };
53501     } catch (std::exception& e) {
53502       {
53503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53504       };
53505     } catch (Dali::DaliException e) {
53506       {
53507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53508       };
53509     } catch (...) {
53510       {
53511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53512       };
53513     }
53514   }
53515
53516 }
53517
53518
53519 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PanGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53520   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53521   Dali::Actor arg2 ;
53522   Dali::PanGesture *arg3 = 0 ;
53523   Dali::Actor *argp2 ;
53524
53525   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53526   argp2 = (Dali::Actor *)jarg2;
53527   if (!argp2) {
53528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53529     return ;
53530   }
53531   arg2 = *argp2;
53532   arg3 = (Dali::PanGesture *)jarg3;
53533   if (!arg3) {
53534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
53535     return ;
53536   }
53537   {
53538     try {
53539       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PanGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PanGesture const &)*arg3);
53540     } catch (std::out_of_range& e) {
53541       {
53542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53543       };
53544     } catch (std::exception& e) {
53545       {
53546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53547       };
53548     } catch (Dali::DaliException e) {
53549       {
53550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53551       };
53552     } catch (...) {
53553       {
53554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53555       };
53556     }
53557   }
53558
53559 }
53560
53561
53562 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PanGestureDetectedSignal() {
53563   void * jresult ;
53564   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *result = 0 ;
53565
53566   {
53567     try {
53568       result = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) >();
53569     } catch (std::out_of_range& e) {
53570       {
53571         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53572       };
53573     } catch (std::exception& e) {
53574       {
53575         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53576       };
53577     } catch (Dali::DaliException e) {
53578       {
53579         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53580       };
53581     } catch (...) {
53582       {
53583         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53584       };
53585     }
53586   }
53587
53588   jresult = (void *)result;
53589   return jresult;
53590 }
53591
53592
53593 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PanGestureDetectedSignal(void * jarg1) {
53594   Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *) 0 ;
53595
53596   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PanGesture const &) > *)jarg1;
53597   {
53598     try {
53599       delete arg1;
53600     } catch (std::out_of_range& e) {
53601       {
53602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53603       };
53604     } catch (std::exception& e) {
53605       {
53606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53607       };
53608     } catch (Dali::DaliException e) {
53609       {
53610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53611       };
53612     } catch (...) {
53613       {
53614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53615       };
53616     }
53617   }
53618
53619 }
53620
53621
53622 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Empty(void * jarg1) {
53623   unsigned int jresult ;
53624   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53625   bool result;
53626
53627   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53628   {
53629     try {
53630       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);
53631     } catch (std::out_of_range& e) {
53632       {
53633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53634       };
53635     } catch (std::exception& e) {
53636       {
53637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53638       };
53639     } catch (Dali::DaliException e) {
53640       {
53641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53642       };
53643     } catch (...) {
53644       {
53645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53646       };
53647     }
53648   }
53649
53650   jresult = result;
53651   return jresult;
53652 }
53653
53654
53655 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53656   unsigned long jresult ;
53657   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53658   std::size_t result;
53659
53660   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53661   {
53662     try {
53663       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);
53664     } catch (std::out_of_range& e) {
53665       {
53666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53667       };
53668     } catch (std::exception& e) {
53669       {
53670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53671       };
53672     } catch (Dali::DaliException e) {
53673       {
53674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53675       };
53676     } catch (...) {
53677       {
53678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53679       };
53680     }
53681   }
53682
53683   jresult = (unsigned long)result;
53684   return jresult;
53685 }
53686
53687
53688 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53689   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53690   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53691
53692   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53693   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53694   {
53695     try {
53696       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53697     } catch (std::out_of_range& e) {
53698       {
53699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53700       };
53701     } catch (std::exception& e) {
53702       {
53703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53704       };
53705     } catch (Dali::DaliException e) {
53706       {
53707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53708       };
53709     } catch (...) {
53710       {
53711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53712       };
53713     }
53714   }
53715
53716 }
53717
53718
53719 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53720   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53721   void (*arg2)(Dali::Actor,Dali::PinchGesture const &) = (void (*)(Dali::Actor,Dali::PinchGesture const &)) 0 ;
53722
53723   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53724   arg2 = (void (*)(Dali::Actor,Dali::PinchGesture const &))jarg2;
53725   {
53726     try {
53727       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53728     } catch (std::out_of_range& e) {
53729       {
53730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53731       };
53732     } catch (std::exception& e) {
53733       {
53734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53735       };
53736     } catch (Dali::DaliException e) {
53737       {
53738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53739       };
53740     } catch (...) {
53741       {
53742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53743       };
53744     }
53745   }
53746
53747 }
53748
53749
53750 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PinchGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53751   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53752   Dali::Actor arg2 ;
53753   Dali::PinchGesture *arg3 = 0 ;
53754   Dali::Actor *argp2 ;
53755
53756   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53757   argp2 = (Dali::Actor *)jarg2;
53758   if (!argp2) {
53759     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53760     return ;
53761   }
53762   arg2 = *argp2;
53763   arg3 = (Dali::PinchGesture *)jarg3;
53764   if (!arg3) {
53765     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
53766     return ;
53767   }
53768   {
53769     try {
53770       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_PinchGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::PinchGesture const &)*arg3);
53771     } catch (std::out_of_range& e) {
53772       {
53773         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53774       };
53775     } catch (std::exception& e) {
53776       {
53777         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53778       };
53779     } catch (Dali::DaliException e) {
53780       {
53781         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53782       };
53783     } catch (...) {
53784       {
53785         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53786       };
53787     }
53788   }
53789
53790 }
53791
53792
53793 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PinchGestureDetectedSignal() {
53794   void * jresult ;
53795   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *result = 0 ;
53796
53797   {
53798     try {
53799       result = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) >();
53800     } catch (std::out_of_range& e) {
53801       {
53802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53803       };
53804     } catch (std::exception& e) {
53805       {
53806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53807       };
53808     } catch (Dali::DaliException e) {
53809       {
53810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53811       };
53812     } catch (...) {
53813       {
53814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53815       };
53816     }
53817   }
53818
53819   jresult = (void *)result;
53820   return jresult;
53821 }
53822
53823
53824 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PinchGestureDetectedSignal(void * jarg1) {
53825   Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *) 0 ;
53826
53827   arg1 = (Dali::Signal< void (Dali::Actor,Dali::PinchGesture const &) > *)jarg1;
53828   {
53829     try {
53830       delete arg1;
53831     } catch (std::out_of_range& e) {
53832       {
53833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53834       };
53835     } catch (std::exception& e) {
53836       {
53837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53838       };
53839     } catch (Dali::DaliException e) {
53840       {
53841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53842       };
53843     } catch (...) {
53844       {
53845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53846       };
53847     }
53848   }
53849
53850 }
53851
53852
53853 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Empty(void * jarg1) {
53854   unsigned int jresult ;
53855   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53856   bool result;
53857
53858   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53859   {
53860     try {
53861       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);
53862     } catch (std::out_of_range& e) {
53863       {
53864         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53865       };
53866     } catch (std::exception& e) {
53867       {
53868         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53869       };
53870     } catch (Dali::DaliException e) {
53871       {
53872         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53873       };
53874     } catch (...) {
53875       {
53876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53877       };
53878     }
53879   }
53880
53881   jresult = result;
53882   return jresult;
53883 }
53884
53885
53886 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_GetConnectionCount(void * jarg1) {
53887   unsigned long jresult ;
53888   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53889   std::size_t result;
53890
53891   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53892   {
53893     try {
53894       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);
53895     } catch (std::out_of_range& e) {
53896       {
53897         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
53898       };
53899     } catch (std::exception& e) {
53900       {
53901         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
53902       };
53903     } catch (Dali::DaliException e) {
53904       {
53905         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
53906       };
53907     } catch (...) {
53908       {
53909         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
53910       };
53911     }
53912   }
53913
53914   jresult = (unsigned long)result;
53915   return jresult;
53916 }
53917
53918
53919 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Connect(void * jarg1, void * jarg2) {
53920   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53921   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53922
53923   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53924   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53925   {
53926     try {
53927       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Connect(arg1,arg2);
53928     } catch (std::out_of_range& e) {
53929       {
53930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53931       };
53932     } catch (std::exception& e) {
53933       {
53934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53935       };
53936     } catch (Dali::DaliException e) {
53937       {
53938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53939       };
53940     } catch (...) {
53941       {
53942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53943       };
53944     }
53945   }
53946
53947 }
53948
53949
53950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Disconnect(void * jarg1, void * jarg2) {
53951   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53952   void (*arg2)(Dali::Actor,Dali::TapGesture const &) = (void (*)(Dali::Actor,Dali::TapGesture const &)) 0 ;
53953
53954   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53955   arg2 = (void (*)(Dali::Actor,Dali::TapGesture const &))jarg2;
53956   {
53957     try {
53958       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
53959     } catch (std::out_of_range& e) {
53960       {
53961         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
53962       };
53963     } catch (std::exception& e) {
53964       {
53965         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
53966       };
53967     } catch (Dali::DaliException e) {
53968       {
53969         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
53970       };
53971     } catch (...) {
53972       {
53973         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
53974       };
53975     }
53976   }
53977
53978 }
53979
53980
53981 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TapGestureDetectedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
53982   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
53983   Dali::Actor arg2 ;
53984   Dali::TapGesture *arg3 = 0 ;
53985   Dali::Actor *argp2 ;
53986
53987   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
53988   argp2 = (Dali::Actor *)jarg2;
53989   if (!argp2) {
53990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
53991     return ;
53992   }
53993   arg2 = *argp2;
53994   arg3 = (Dali::TapGesture *)jarg3;
53995   if (!arg3) {
53996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
53997     return ;
53998   }
53999   {
54000     try {
54001       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_TapGesture_SS_const_SA__SP__Sg__Emit(arg1,arg2,(Dali::TapGesture const &)*arg3);
54002     } catch (std::out_of_range& e) {
54003       {
54004         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54005       };
54006     } catch (std::exception& e) {
54007       {
54008         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54009       };
54010     } catch (Dali::DaliException e) {
54011       {
54012         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54013       };
54014     } catch (...) {
54015       {
54016         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54017       };
54018     }
54019   }
54020
54021 }
54022
54023
54024 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TapGestureDetectedSignal() {
54025   void * jresult ;
54026   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *result = 0 ;
54027
54028   {
54029     try {
54030       result = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)new Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) >();
54031     } catch (std::out_of_range& e) {
54032       {
54033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54034       };
54035     } catch (std::exception& e) {
54036       {
54037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54038       };
54039     } catch (Dali::DaliException e) {
54040       {
54041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54042       };
54043     } catch (...) {
54044       {
54045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54046       };
54047     }
54048   }
54049
54050   jresult = (void *)result;
54051   return jresult;
54052 }
54053
54054
54055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TapGestureDetectedSignal(void * jarg1) {
54056   Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *) 0 ;
54057
54058   arg1 = (Dali::Signal< void (Dali::Actor,Dali::TapGesture const &) > *)jarg1;
54059   {
54060     try {
54061       delete arg1;
54062     } catch (std::out_of_range& e) {
54063       {
54064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54065       };
54066     } catch (std::exception& e) {
54067       {
54068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54069       };
54070     } catch (Dali::DaliException e) {
54071       {
54072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54073       };
54074     } catch (...) {
54075       {
54076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54077       };
54078     }
54079   }
54080
54081 }
54082
54083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionChangedSignal_Empty(void * jarg1) {
54084   unsigned int jresult ;
54085   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54086   bool result = false;
54087
54088   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54089   {
54090     try {
54091       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);
54092     } catch (std::out_of_range& e) {
54093       {
54094         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54095       };
54096     } catch (std::exception& e) {
54097       {
54098         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54099       };
54100     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54101   }
54102   jresult = result;
54103   return jresult;
54104 }
54105
54106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_GetConnectionCount(void * jarg1) {
54107   unsigned long jresult ;
54108   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54109   std::size_t result = 0;
54110
54111   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54112   {
54113     try {
54114       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);
54115     } catch (std::out_of_range& e) {
54116       {
54117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54118       };
54119     } catch (std::exception& e) {
54120       {
54121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54122       };
54123     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54124   }
54125   jresult = (unsigned long)result;
54126   return jresult;
54127 }
54128
54129 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Connect(void * jarg1, void * jarg2) {
54130   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54131   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54132
54133   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54134   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54135   {
54136     try {
54137       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Connect(arg1,arg2);
54138     } catch (std::out_of_range& e) {
54139       {
54140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54141       };
54142     } catch (std::exception& e) {
54143       {
54144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54145       };
54146     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54147   }
54148 }
54149
54150 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Disconnect(void * jarg1, void * jarg2) {
54151   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54152   void (*arg2)(Dali::Actor, Dali::LayoutDirection::Type) = (void (*)(Dali::Actor, Dali::LayoutDirection::Type)) 0 ;
54153
54154   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54155   arg2 = (void (*)(Dali::Actor, Dali::LayoutDirection::Type))jarg2;
54156   {
54157     try {
54158       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Disconnect(arg1,arg2);
54159     } catch (std::out_of_range& e) {
54160       {
54161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54162       };
54163     } catch (std::exception& e) {
54164       {
54165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54166       };
54167     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54168   }
54169 }
54170
54171 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewLayoutDirectionSignal_Emit(void * jarg1, void * jarg2, int jarg4) {
54172   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54173   Dali::Actor arg2 ;
54174   //bool arg3 ;
54175   Dali::LayoutDirection::Type arg4 ;
54176   Dali::Actor *argp2 ;
54177
54178   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54179   argp2 = (Dali::Actor *)jarg2;
54180   if (!argp2) {
54181     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54182     return ;
54183   }
54184   arg2 = *argp2;
54185   //arg3 = jarg3 ? true : false;
54186   arg4 = (Dali::LayoutDirection::Type)jarg4;
54187   {
54188     try {
54189       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_LayoutDirection_Type_SP__Sg__Emit(arg1,arg2,arg4);
54190     } catch (std::out_of_range& e) {
54191       {
54192         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54193       };
54194     } catch (std::exception& e) {
54195       {
54196         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54197       };
54198     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54199   }
54200 }
54201
54202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewLayoutDirectionSignal() {
54203   void * jresult ;
54204   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *result = 0 ;
54205
54206   {
54207     try {
54208       result = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)new Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) >();
54209     } catch (std::out_of_range& e) {
54210       {
54211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54212       };
54213     } catch (std::exception& e) {
54214       {
54215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54216       };
54217     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54218   }
54219   jresult = (void *)result;
54220   return jresult;
54221 }
54222
54223 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewLayoutDirectionSignal(void * jarg1) {
54224   Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *) 0 ;
54225
54226   arg1 = (Dali::Signal< void (Dali::Actor, Dali::LayoutDirection::Type) > *)jarg1;
54227   {
54228     try {
54229       delete arg1;
54230     } catch (std::out_of_range& e) {
54231       {
54232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54233       };
54234     } catch (std::exception& e) {
54235       {
54236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54237       };
54238     } catch (DaliException e) { SWIG_CSharpException(SWIG_UnknownError, e.condition); return ; } catch (...) { SWIG_CSharpException(SWIG_UnknownError, "unknown error");}
54239   }
54240 }
54241
54242 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Empty(void * jarg1) {
54243   unsigned int jresult ;
54244   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54245   bool result;
54246
54247   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54248   {
54249     try {
54250       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);
54251     } catch (std::out_of_range& e) {
54252       {
54253         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54254       };
54255     } catch (std::exception& e) {
54256       {
54257         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54258       };
54259     } catch (Dali::DaliException e) {
54260       {
54261         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54262       };
54263     } catch (...) {
54264       {
54265         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54266       };
54267     }
54268   }
54269
54270   jresult = result;
54271   return jresult;
54272 }
54273
54274
54275 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_GetConnectionCount(void * jarg1) {
54276   unsigned long jresult ;
54277   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54278   std::size_t result;
54279
54280   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54281   {
54282     try {
54283       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);
54284     } catch (std::out_of_range& e) {
54285       {
54286         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54287       };
54288     } catch (std::exception& e) {
54289       {
54290         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54291       };
54292     } catch (Dali::DaliException e) {
54293       {
54294         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54295       };
54296     } catch (...) {
54297       {
54298         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54299       };
54300     }
54301   }
54302
54303   jresult = (unsigned long)result;
54304   return jresult;
54305 }
54306
54307
54308 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Connect(void * jarg1, void * jarg2) {
54309   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54310   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54311
54312   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54313   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54314   {
54315     try {
54316       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Connect(arg1,arg2);
54317     } catch (std::out_of_range& e) {
54318       {
54319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54320       };
54321     } catch (std::exception& e) {
54322       {
54323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54324       };
54325     } catch (Dali::DaliException e) {
54326       {
54327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54328       };
54329     } catch (...) {
54330       {
54331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54332       };
54333     }
54334   }
54335
54336 }
54337
54338
54339 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Disconnect(void * jarg1, void * jarg2) {
54340   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54341   void (*arg2)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type)) 0 ;
54342
54343   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54344   arg2 = (void (*)(Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type))jarg2;
54345   {
54346     try {
54347       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Disconnect(arg1,arg2);
54348     } catch (std::out_of_range& e) {
54349       {
54350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54351       };
54352     } catch (std::exception& e) {
54353       {
54354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54355       };
54356     } catch (Dali::DaliException e) {
54357       {
54358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54359       };
54360     } catch (...) {
54361       {
54362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54363       };
54364     }
54365   }
54366
54367 }
54368
54369
54370 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewVisibilityChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, int jarg4) {
54371   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54372   Dali::Actor arg2 ;
54373   bool arg3 ;
54374   Dali::DevelActor::VisibilityChange::Type arg4 ;
54375   Dali::Actor *argp2 ;
54376
54377   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54378   argp2 = (Dali::Actor *)jarg2;
54379   if (!argp2) {
54380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
54381     return ;
54382   }
54383   arg2 = *argp2;
54384   arg3 = jarg3 ? true : false;
54385   arg4 = (Dali::DevelActor::VisibilityChange::Type)jarg4;
54386   {
54387     try {
54388       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_Sc_Dali_DevelActor_VisibilityChange_Type_SP__Sg__Emit(arg1,arg2,arg3,arg4);
54389     } catch (std::out_of_range& e) {
54390       {
54391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54392       };
54393     } catch (std::exception& e) {
54394       {
54395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54396       };
54397     } catch (Dali::DaliException e) {
54398       {
54399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54400       };
54401     } catch (...) {
54402       {
54403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54404       };
54405     }
54406   }
54407
54408 }
54409
54410
54411 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewVisibilityChangedSignal() {
54412   void * jresult ;
54413   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *result = 0 ;
54414
54415   {
54416     try {
54417       result = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)new Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) >();
54418     } catch (std::out_of_range& e) {
54419       {
54420         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54421       };
54422     } catch (std::exception& e) {
54423       {
54424         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54425       };
54426     } catch (Dali::DaliException e) {
54427       {
54428         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54429       };
54430     } catch (...) {
54431       {
54432         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54433       };
54434     }
54435   }
54436
54437   jresult = (void *)result;
54438   return jresult;
54439 }
54440
54441
54442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewVisibilityChangedSignal(void * jarg1) {
54443   Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *) 0 ;
54444
54445   arg1 = (Dali::Signal< void (Dali::Actor,bool,Dali::DevelActor::VisibilityChange::Type) > *)jarg1;
54446   {
54447     try {
54448       delete arg1;
54449     } catch (std::out_of_range& e) {
54450       {
54451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54452       };
54453     } catch (std::exception& e) {
54454       {
54455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54456       };
54457     } catch (Dali::DaliException e) {
54458       {
54459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54460       };
54461     } catch (...) {
54462       {
54463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54464       };
54465     }
54466   }
54467
54468 }
54469
54470
54471 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_0() {
54472   void * jresult ;
54473   Dali::Timer *result = 0 ;
54474
54475   {
54476     try {
54477       result = (Dali::Timer *)new Dali::Timer();
54478     } catch (std::out_of_range& e) {
54479       {
54480         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54481       };
54482     } catch (std::exception& e) {
54483       {
54484         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54485       };
54486     } catch (Dali::DaliException e) {
54487       {
54488         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54489       };
54490     } catch (...) {
54491       {
54492         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54493       };
54494     }
54495   }
54496
54497   jresult = (void *)result;
54498   return jresult;
54499 }
54500
54501
54502 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_New(unsigned int jarg1) {
54503   void * jresult ;
54504   unsigned int arg1 ;
54505   Dali::Timer result;
54506
54507   arg1 = (unsigned int)jarg1;
54508   {
54509     try {
54510       result = Dali::Timer::New(arg1);
54511     } catch (std::out_of_range& e) {
54512       {
54513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54514       };
54515     } catch (std::exception& e) {
54516       {
54517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54518       };
54519     } catch (Dali::DaliException e) {
54520       {
54521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54522       };
54523     } catch (...) {
54524       {
54525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54526       };
54527     }
54528   }
54529
54530   jresult = new Dali::Timer((const Dali::Timer &)result);
54531   return jresult;
54532 }
54533
54534
54535 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Timer__SWIG_1(void * jarg1) {
54536   void * jresult ;
54537   Dali::Timer *arg1 = 0 ;
54538   Dali::Timer *result = 0 ;
54539
54540   arg1 = (Dali::Timer *)jarg1;
54541   if (!arg1) {
54542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54543     return 0;
54544   }
54545   {
54546     try {
54547       result = (Dali::Timer *)new Dali::Timer((Dali::Timer const &)*arg1);
54548     } catch (std::out_of_range& e) {
54549       {
54550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54551       };
54552     } catch (std::exception& e) {
54553       {
54554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54555       };
54556     } catch (Dali::DaliException e) {
54557       {
54558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54559       };
54560     } catch (...) {
54561       {
54562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54563       };
54564     }
54565   }
54566
54567   jresult = (void *)result;
54568   return jresult;
54569 }
54570
54571
54572 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_Assign(void * jarg1, void * jarg2) {
54573   void * jresult ;
54574   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54575   Dali::Timer *arg2 = 0 ;
54576   Dali::Timer *result = 0 ;
54577
54578   arg1 = (Dali::Timer *)jarg1;
54579   arg2 = (Dali::Timer *)jarg2;
54580   if (!arg2) {
54581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Timer const & type is null", 0);
54582     return 0;
54583   }
54584   {
54585     try {
54586       result = (Dali::Timer *) &(arg1)->operator =((Dali::Timer const &)*arg2);
54587     } catch (std::out_of_range& e) {
54588       {
54589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54590       };
54591     } catch (std::exception& e) {
54592       {
54593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54594       };
54595     } catch (Dali::DaliException e) {
54596       {
54597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54598       };
54599     } catch (...) {
54600       {
54601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54602       };
54603     }
54604   }
54605
54606   jresult = (void *)result;
54607   return jresult;
54608 }
54609
54610
54611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Timer(void * jarg1) {
54612   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54613
54614   arg1 = (Dali::Timer *)jarg1;
54615   {
54616     try {
54617       delete arg1;
54618     } catch (std::out_of_range& e) {
54619       {
54620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54621       };
54622     } catch (std::exception& e) {
54623       {
54624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54625       };
54626     } catch (Dali::DaliException e) {
54627       {
54628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54629       };
54630     } catch (...) {
54631       {
54632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54633       };
54634     }
54635   }
54636
54637 }
54638
54639
54640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_DownCast(void * jarg1) {
54641   void * jresult ;
54642   Dali::BaseHandle arg1 ;
54643   Dali::BaseHandle *argp1 ;
54644   Dali::Timer result;
54645
54646   argp1 = (Dali::BaseHandle *)jarg1;
54647   if (!argp1) {
54648     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
54649     return 0;
54650   }
54651   arg1 = *argp1;
54652   {
54653     try {
54654       result = Dali::Timer::DownCast(arg1);
54655     } catch (std::out_of_range& e) {
54656       {
54657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54658       };
54659     } catch (std::exception& e) {
54660       {
54661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54662       };
54663     } catch (Dali::DaliException e) {
54664       {
54665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54666       };
54667     } catch (...) {
54668       {
54669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54670       };
54671     }
54672   }
54673
54674   jresult = new Dali::Timer((const Dali::Timer &)result);
54675   return jresult;
54676 }
54677
54678
54679 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Start(void * jarg1) {
54680   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54681
54682   arg1 = (Dali::Timer *)jarg1;
54683   {
54684     try {
54685       (arg1)->Start();
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 (Dali::DaliException e) {
54695       {
54696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54697       };
54698     } catch (...) {
54699       {
54700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54701       };
54702     }
54703   }
54704
54705 }
54706
54707
54708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_Stop(void * jarg1) {
54709   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54710
54711   arg1 = (Dali::Timer *)jarg1;
54712   {
54713     try {
54714       (arg1)->Stop();
54715     } catch (std::out_of_range& e) {
54716       {
54717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54718       };
54719     } catch (std::exception& e) {
54720       {
54721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54722       };
54723     } catch (Dali::DaliException e) {
54724       {
54725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54726       };
54727     } catch (...) {
54728       {
54729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54730       };
54731     }
54732   }
54733
54734 }
54735
54736
54737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Timer_SetInterval(void * jarg1, unsigned int jarg2) {
54738   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54739   unsigned int arg2 ;
54740
54741   arg1 = (Dali::Timer *)jarg1;
54742   arg2 = (unsigned int)jarg2;
54743   {
54744     try {
54745       (arg1)->SetInterval(arg2);
54746     } catch (std::out_of_range& e) {
54747       {
54748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54749       };
54750     } catch (std::exception& e) {
54751       {
54752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54753       };
54754     } catch (Dali::DaliException e) {
54755       {
54756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54757       };
54758     } catch (...) {
54759       {
54760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54761       };
54762     }
54763   }
54764
54765 }
54766
54767
54768 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_GetInterval(void * jarg1) {
54769   unsigned int jresult ;
54770   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54771   unsigned int result;
54772
54773   arg1 = (Dali::Timer *)jarg1;
54774   {
54775     try {
54776       result = (unsigned int)((Dali::Timer const *)arg1)->GetInterval();
54777     } catch (std::out_of_range& e) {
54778       {
54779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54780       };
54781     } catch (std::exception& e) {
54782       {
54783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54784       };
54785     } catch (Dali::DaliException e) {
54786       {
54787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54788       };
54789     } catch (...) {
54790       {
54791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54792       };
54793     }
54794   }
54795
54796   jresult = result;
54797   return jresult;
54798 }
54799
54800
54801 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Timer_IsRunning(void * jarg1) {
54802   unsigned int jresult ;
54803   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54804   bool result;
54805
54806   arg1 = (Dali::Timer *)jarg1;
54807   {
54808     try {
54809       result = (bool)((Dali::Timer const *)arg1)->IsRunning();
54810     } catch (std::out_of_range& e) {
54811       {
54812         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54813       };
54814     } catch (std::exception& e) {
54815       {
54816         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54817       };
54818     } catch (Dali::DaliException e) {
54819       {
54820         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54821       };
54822     } catch (...) {
54823       {
54824         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54825       };
54826     }
54827   }
54828
54829   jresult = result;
54830   return jresult;
54831 }
54832
54833
54834 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Timer_TickSignal(void * jarg1) {
54835   void * jresult ;
54836   Dali::Timer *arg1 = (Dali::Timer *) 0 ;
54837   Dali::Timer::TimerSignalType *result = 0 ;
54838
54839   arg1 = (Dali::Timer *)jarg1;
54840   {
54841     try {
54842       result = (Dali::Timer::TimerSignalType *) &(arg1)->TickSignal();
54843     } catch (std::out_of_range& e) {
54844       {
54845         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54846       };
54847     } catch (std::exception& e) {
54848       {
54849         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54850       };
54851     } catch (Dali::DaliException e) {
54852       {
54853         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54854       };
54855     } catch (...) {
54856       {
54857         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54858       };
54859     }
54860   }
54861
54862   jresult = (void *)result;
54863   return jresult;
54864 }
54865
54866
54867 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Empty(void * jarg1) {
54868   unsigned int jresult ;
54869   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54870   bool result;
54871
54872   arg1 = (Dali::Signal< bool () > *)jarg1;
54873   {
54874     try {
54875       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Empty((Dali::Signal< bool () > const *)arg1);
54876     } catch (std::out_of_range& e) {
54877       {
54878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54879       };
54880     } catch (std::exception& e) {
54881       {
54882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54883       };
54884     } catch (Dali::DaliException e) {
54885       {
54886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54887       };
54888     } catch (...) {
54889       {
54890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54891       };
54892     }
54893   }
54894
54895   jresult = result;
54896   return jresult;
54897 }
54898
54899
54900 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TimerSignalType_GetConnectionCount(void * jarg1) {
54901   unsigned long jresult ;
54902   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54903   std::size_t result;
54904
54905   arg1 = (Dali::Signal< bool () > *)jarg1;
54906   {
54907     try {
54908       result = Dali_Signal_Sl_bool_Sp__SP__Sg__GetConnectionCount((Dali::Signal< bool () > const *)arg1);
54909     } catch (std::out_of_range& e) {
54910       {
54911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
54912       };
54913     } catch (std::exception& e) {
54914       {
54915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
54916       };
54917     } catch (Dali::DaliException e) {
54918       {
54919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
54920       };
54921     } catch (...) {
54922       {
54923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
54924       };
54925     }
54926   }
54927
54928   jresult = (unsigned long)result;
54929   return jresult;
54930 }
54931
54932
54933 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Connect(void * jarg1, void * jarg2) {
54934   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54935   bool (*arg2)() = (bool (*)()) 0 ;
54936
54937   arg1 = (Dali::Signal< bool () > *)jarg1;
54938   arg2 = (bool (*)())jarg2;
54939   {
54940     try {
54941       Dali_Signal_Sl_bool_Sp__SP__Sg__Connect(arg1,arg2);
54942     } catch (std::out_of_range& e) {
54943       {
54944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54945       };
54946     } catch (std::exception& e) {
54947       {
54948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54949       };
54950     } catch (Dali::DaliException e) {
54951       {
54952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54953       };
54954     } catch (...) {
54955       {
54956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54957       };
54958     }
54959   }
54960
54961 }
54962
54963
54964 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TimerSignalType_Disconnect(void * jarg1, void * jarg2) {
54965   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54966   bool (*arg2)() = (bool (*)()) 0 ;
54967
54968   arg1 = (Dali::Signal< bool () > *)jarg1;
54969   arg2 = (bool (*)())jarg2;
54970   {
54971     try {
54972       Dali_Signal_Sl_bool_Sp__SP__Sg__Disconnect(arg1,arg2);
54973     } catch (std::out_of_range& e) {
54974       {
54975         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
54976       };
54977     } catch (std::exception& e) {
54978       {
54979         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
54980       };
54981     } catch (Dali::DaliException e) {
54982       {
54983         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
54984       };
54985     } catch (...) {
54986       {
54987         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
54988       };
54989     }
54990   }
54991
54992 }
54993
54994
54995 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TimerSignalType_Emit(void * jarg1) {
54996   unsigned int jresult ;
54997   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
54998   bool result;
54999
55000   arg1 = (Dali::Signal< bool () > *)jarg1;
55001   {
55002     try {
55003       result = (bool)Dali_Signal_Sl_bool_Sp__SP__Sg__Emit(arg1);
55004     } catch (std::out_of_range& e) {
55005       {
55006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55007       };
55008     } catch (std::exception& e) {
55009       {
55010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55011       };
55012     } catch (Dali::DaliException e) {
55013       {
55014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55015       };
55016     } catch (...) {
55017       {
55018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55019       };
55020     }
55021   }
55022
55023   jresult = result;
55024   return jresult;
55025 }
55026
55027
55028 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TimerSignalType() {
55029   void * jresult ;
55030   Dali::Signal< bool () > *result = 0 ;
55031
55032   {
55033     try {
55034       result = (Dali::Signal< bool () > *)new Dali::Signal< bool () >();
55035     } catch (std::out_of_range& e) {
55036       {
55037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55038       };
55039     } catch (std::exception& e) {
55040       {
55041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55042       };
55043     } catch (Dali::DaliException e) {
55044       {
55045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55046       };
55047     } catch (...) {
55048       {
55049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55050       };
55051     }
55052   }
55053
55054   jresult = (void *)result;
55055   return jresult;
55056 }
55057
55058
55059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TimerSignalType(void * jarg1) {
55060   Dali::Signal< bool () > *arg1 = (Dali::Signal< bool () > *) 0 ;
55061
55062   arg1 = (Dali::Signal< bool () > *)jarg1;
55063   {
55064     try {
55065       delete arg1;
55066     } catch (std::out_of_range& e) {
55067       {
55068         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
55069       };
55070     } catch (std::exception& e) {
55071       {
55072         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
55073       };
55074     } catch (Dali::DaliException e) {
55075       {
55076         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
55077       };
55078     } catch (...) {
55079       {
55080         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
55081       };
55082     }
55083   }
55084
55085 }
55086
55087
55088 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_TYPE_get() {
55089   int jresult ;
55090   int result;
55091
55092   {
55093     try {
55094       result = (int)Dali::Toolkit::Visual::Property::TYPE;
55095     } catch (std::out_of_range& e) {
55096       {
55097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55098       };
55099     } catch (std::exception& e) {
55100       {
55101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55102       };
55103     } catch (Dali::DaliException e) {
55104       {
55105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55106       };
55107     } catch (...) {
55108       {
55109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55110       };
55111     }
55112   }
55113
55114   jresult = (int)result;
55115   return jresult;
55116 }
55117
55118
55119 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_PROPERTY_SHADER_get() {
55120   int jresult ;
55121   int result;
55122
55123   {
55124     try {
55125       result = (int)Dali::Toolkit::Visual::Property::SHADER;
55126     } catch (std::out_of_range& e) {
55127       {
55128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55129       };
55130     } catch (std::exception& e) {
55131       {
55132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55133       };
55134     } catch (Dali::DaliException e) {
55135       {
55136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55137       };
55138     } catch (...) {
55139       {
55140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55141       };
55142     }
55143   }
55144
55145   jresult = (int)result;
55146   return jresult;
55147 }
55148
55149
55150 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_VERTEX_get() {
55151   int jresult ;
55152   int result;
55153
55154   {
55155     try {
55156       result = (int)Dali::Toolkit::Visual::Shader::Property::VERTEX_SHADER;
55157     } catch (std::out_of_range& e) {
55158       {
55159         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55160       };
55161     } catch (std::exception& e) {
55162       {
55163         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55164       };
55165     } catch (Dali::DaliException e) {
55166       {
55167         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55168       };
55169     } catch (...) {
55170       {
55171         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55172       };
55173     }
55174   }
55175
55176   jresult = (int)result;
55177   return jresult;
55178 }
55179
55180
55181 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_FRAGMENT_get() {
55182   int jresult ;
55183   int result;
55184
55185   {
55186     try {
55187       result = (int)Dali::Toolkit::Visual::Shader::Property::FRAGMENT_SHADER;
55188     } catch (std::out_of_range& e) {
55189       {
55190         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55191       };
55192     } catch (std::exception& e) {
55193       {
55194         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55195       };
55196     } catch (Dali::DaliException e) {
55197       {
55198         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55199       };
55200     } catch (...) {
55201       {
55202         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55203       };
55204     }
55205   }
55206
55207   jresult = (int)result;
55208   return jresult;
55209 }
55210
55211
55212 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_X_get() {
55213   int jresult ;
55214   int result;
55215
55216   {
55217     try {
55218       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_X;
55219     } catch (std::out_of_range& e) {
55220       {
55221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55222       };
55223     } catch (std::exception& e) {
55224       {
55225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55226       };
55227     } catch (Dali::DaliException e) {
55228       {
55229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55230       };
55231     } catch (...) {
55232       {
55233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55234       };
55235     }
55236   }
55237
55238   jresult = (int)result;
55239   return jresult;
55240 }
55241
55242
55243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_SUBDIVIDE_GRID_Y_get() {
55244   int jresult ;
55245   int result;
55246
55247   {
55248     try {
55249       result = (int)Dali::Toolkit::Visual::Shader::Property::SUBDIVIDE_GRID_Y;
55250     } catch (std::out_of_range& e) {
55251       {
55252         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55253       };
55254     } catch (std::exception& e) {
55255       {
55256         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55257       };
55258     } catch (Dali::DaliException e) {
55259       {
55260         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55261       };
55262     } catch (...) {
55263       {
55264         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55265       };
55266     }
55267   }
55268
55269   jresult = (int)result;
55270   return jresult;
55271 }
55272
55273
55274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VISUAL_SHADER_HINTS_get() {
55275   int jresult ;
55276   int result;
55277
55278   {
55279     try {
55280       result = (int)Dali::Toolkit::Visual::Shader::Property::HINTS;
55281     } catch (std::out_of_range& e) {
55282       {
55283         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55284       };
55285     } catch (std::exception& e) {
55286       {
55287         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55288       };
55289     } catch (Dali::DaliException e) {
55290       {
55291         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55292       };
55293     } catch (...) {
55294       {
55295         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55296       };
55297     }
55298   }
55299
55300   jresult = (int)result;
55301   return jresult;
55302 }
55303
55304
55305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_COLOR_get() {
55306   int jresult ;
55307   int result;
55308
55309   {
55310     try {
55311       result = (int)Dali::Toolkit::BorderVisual::Property::COLOR;
55312     } catch (std::out_of_range& e) {
55313       {
55314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55315       };
55316     } catch (std::exception& e) {
55317       {
55318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55319       };
55320     } catch (Dali::DaliException e) {
55321       {
55322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55323       };
55324     } catch (...) {
55325       {
55326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55327       };
55328     }
55329   }
55330
55331   jresult = (int)result;
55332   return jresult;
55333 }
55334
55335
55336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_SIZE_get() {
55337   int jresult ;
55338   int result;
55339
55340   {
55341     try {
55342       result = (int)Dali::Toolkit::BorderVisual::Property::SIZE;
55343     } catch (std::out_of_range& e) {
55344       {
55345         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55346       };
55347     } catch (std::exception& e) {
55348       {
55349         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55350       };
55351     } catch (Dali::DaliException e) {
55352       {
55353         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55354       };
55355     } catch (...) {
55356       {
55357         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55358       };
55359     }
55360   }
55361
55362   jresult = (int)result;
55363   return jresult;
55364 }
55365
55366
55367 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_BORDER_VISUAL_ANTI_ALIASING_get() {
55368   int jresult ;
55369   int result;
55370
55371   {
55372     try {
55373       result = (int)Dali::Toolkit::BorderVisual::Property::ANTI_ALIASING;
55374     } catch (std::out_of_range& e) {
55375       {
55376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55377       };
55378     } catch (std::exception& e) {
55379       {
55380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55381       };
55382     } catch (Dali::DaliException e) {
55383       {
55384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55385       };
55386     } catch (...) {
55387       {
55388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55389       };
55390     }
55391   }
55392
55393   jresult = (int)result;
55394   return jresult;
55395 }
55396
55397
55398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_COLOR_VISUAL_MIX_COLOR_get() {
55399   int jresult ;
55400   int result;
55401
55402   {
55403     try {
55404       result = (int)Dali::Toolkit::ColorVisual::Property::MIX_COLOR;
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 = (int)result;
55425   return jresult;
55426 }
55427
55428
55429 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_START_POSITION_get() {
55430   int jresult ;
55431   int result;
55432
55433   {
55434     try {
55435       result = (int)Dali::Toolkit::GradientVisual::Property::START_POSITION;
55436     } catch (std::out_of_range& e) {
55437       {
55438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55439       };
55440     } catch (std::exception& e) {
55441       {
55442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55443       };
55444     } catch (Dali::DaliException e) {
55445       {
55446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55447       };
55448     } catch (...) {
55449       {
55450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55451       };
55452     }
55453   }
55454
55455   jresult = (int)result;
55456   return jresult;
55457 }
55458
55459
55460 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_END_POSITION_get() {
55461   int jresult ;
55462   int result;
55463
55464   {
55465     try {
55466       result = (int)Dali::Toolkit::GradientVisual::Property::END_POSITION;
55467     } catch (std::out_of_range& e) {
55468       {
55469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55470       };
55471     } catch (std::exception& e) {
55472       {
55473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55474       };
55475     } catch (Dali::DaliException e) {
55476       {
55477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55478       };
55479     } catch (...) {
55480       {
55481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55482       };
55483     }
55484   }
55485
55486   jresult = (int)result;
55487   return jresult;
55488 }
55489
55490
55491 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_CENTER_get() {
55492   int jresult ;
55493   int result;
55494
55495   {
55496     try {
55497       result = (int)Dali::Toolkit::GradientVisual::Property::CENTER;
55498     } catch (std::out_of_range& e) {
55499       {
55500         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55501       };
55502     } catch (std::exception& e) {
55503       {
55504         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55505       };
55506     } catch (Dali::DaliException e) {
55507       {
55508         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55509       };
55510     } catch (...) {
55511       {
55512         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55513       };
55514     }
55515   }
55516
55517   jresult = (int)result;
55518   return jresult;
55519 }
55520
55521
55522 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_RADIUS_get() {
55523   int jresult ;
55524   int result;
55525
55526   {
55527     try {
55528       result = (int)Dali::Toolkit::GradientVisual::Property::RADIUS;
55529     } catch (std::out_of_range& e) {
55530       {
55531         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55532       };
55533     } catch (std::exception& e) {
55534       {
55535         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55536       };
55537     } catch (Dali::DaliException e) {
55538       {
55539         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55540       };
55541     } catch (...) {
55542       {
55543         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55544       };
55545     }
55546   }
55547
55548   jresult = (int)result;
55549   return jresult;
55550 }
55551
55552
55553 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_OFFSET_get() {
55554   int jresult ;
55555   int result;
55556
55557   {
55558     try {
55559       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_OFFSET;
55560     } catch (std::out_of_range& e) {
55561       {
55562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55563       };
55564     } catch (std::exception& e) {
55565       {
55566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55567       };
55568     } catch (Dali::DaliException e) {
55569       {
55570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55571       };
55572     } catch (...) {
55573       {
55574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55575       };
55576     }
55577   }
55578
55579   jresult = (int)result;
55580   return jresult;
55581 }
55582
55583
55584 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GRADIENT_VISUAL_STOP_COLOR_get() {
55585   int jresult ;
55586   int result;
55587
55588   {
55589     try {
55590       result = (int)Dali::Toolkit::GradientVisual::Property::STOP_COLOR;
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_GRADIENT_VISUAL_UNITS_get() {
55616   int jresult ;
55617   int result;
55618
55619   {
55620     try {
55621       result = (int)Dali::Toolkit::GradientVisual::Property::UNITS;
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_GRADIENT_VISUAL_SPREAD_METHOD_get() {
55647   int jresult ;
55648   int result;
55649
55650   {
55651     try {
55652       result = (int)Dali::Toolkit::GradientVisual::Property::SPREAD_METHOD;
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_IMAGE_VISUAL_URL_get() {
55678   int jresult ;
55679   int result;
55680
55681   {
55682     try {
55683       result = (int)Dali::Toolkit::ImageVisual::Property::URL;
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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ALPHA_MASK_URL_get() {
55708   int jresult ;
55709   int result;
55710
55711   {
55712     try {
55713       result = (int)Dali::Toolkit::ImageVisual::Property::ALPHA_MASK_URL;
55714     } catch (std::out_of_range& e) {
55715       {
55716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55717       };
55718     } catch (std::exception& e) {
55719       {
55720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55721       };
55722     } catch (Dali::DaliException e) {
55723       {
55724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55725       };
55726     } catch (...) {
55727       {
55728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55729       };
55730     }
55731   }
55732
55733   jresult = (int)result;
55734   return jresult;
55735 }
55736
55737
55738 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BATCH_SIZE_get() {
55739   int jresult ;
55740   int result;
55741   {
55742     try
55743     {
55744       result = (int)Dali::Toolkit::ImageVisual::Property::BATCH_SIZE;
55745     } catch (std::out_of_range& e) {
55746       {
55747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55748       };
55749     } catch (std::exception& e) {
55750       {
55751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55752       };
55753     } catch (Dali::DaliException e) {
55754       {
55755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55756       };
55757     } catch (...) {
55758       {
55759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55760       };
55761     }
55762   }
55763
55764   jresult = (int)result;
55765   return jresult;
55766 }
55767
55768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CACHE_SIZE_get() {
55769   int jresult ;
55770   int result;
55771   {
55772     try
55773     {
55774       result = (int)Dali::Toolkit::ImageVisual::Property::CACHE_SIZE;
55775     } catch (std::out_of_range& e) {
55776       {
55777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55778       };
55779     } catch (std::exception& e) {
55780       {
55781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55782       };
55783     } catch (Dali::DaliException e) {
55784       {
55785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55786       };
55787     } catch (...) {
55788       {
55789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55790       };
55791     }
55792   }
55793
55794   jresult = (int)result;
55795   return jresult;
55796 }
55797
55798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FRAME_DELAY_get() {
55799   int jresult ;
55800   int result;
55801   {
55802     try
55803     {
55804       result = (int)Dali::Toolkit::ImageVisual::Property::FRAME_DELAY;
55805     } catch (std::out_of_range& e) {
55806       {
55807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55808       };
55809     } catch (std::exception& e) {
55810       {
55811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55812       };
55813     } catch (Dali::DaliException e) {
55814       {
55815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55816       };
55817     } catch (...) {
55818       {
55819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55820       };
55821     }
55822   }
55823
55824   jresult = (int)result;
55825   return jresult;
55826 }
55827
55828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOOP_COUNT_get() {
55829   return (int)Dali::Toolkit::DevelImageVisual::Property::LOOP_COUNT;
55830 }
55831
55832 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_MASK_CONTENT_SCALE_get() {
55833   int jresult ;
55834   int result;
55835   {
55836     try
55837     {
55838       result = (int)Dali::Toolkit::ImageVisual::Property::MASK_CONTENT_SCALE;
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 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_CROP_TO_MASK_get() {
55863   int jresult ;
55864   int result;
55865   {
55866     try
55867     {
55868       result = (int)Dali::Toolkit::ImageVisual::Property::CROP_TO_MASK;
55869     } catch (std::out_of_range& e) {
55870       {
55871         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55872       };
55873     } catch (std::exception& e) {
55874       {
55875         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55876       };
55877     } catch (Dali::DaliException e) {
55878       {
55879         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55880       };
55881     } catch (...) {
55882       {
55883         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55884       };
55885     }
55886   }
55887
55888   jresult = (int)result;
55889   return jresult;
55890 }
55891
55892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_FITTING_MODE_get() {
55893   int jresult ;
55894   int result;
55895
55896   {
55897     try {
55898       result = (int)Dali::Toolkit::ImageVisual::Property::FITTING_MODE;
55899     } catch (std::out_of_range& e) {
55900       {
55901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55902       };
55903     } catch (std::exception& e) {
55904       {
55905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55906       };
55907     } catch (Dali::DaliException e) {
55908       {
55909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55910       };
55911     } catch (...) {
55912       {
55913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55914       };
55915     }
55916   }
55917
55918   jresult = (int)result;
55919   return jresult;
55920 }
55921
55922
55923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SAMPLING_MODE_get() {
55924   int jresult ;
55925   int result;
55926
55927   {
55928     try {
55929       result = (int)Dali::Toolkit::ImageVisual::Property::SAMPLING_MODE;
55930     } catch (std::out_of_range& e) {
55931       {
55932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55933       };
55934     } catch (std::exception& e) {
55935       {
55936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55937       };
55938     } catch (Dali::DaliException e) {
55939       {
55940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
55941       };
55942     } catch (...) {
55943       {
55944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55945       };
55946     }
55947   }
55948
55949   jresult = (int)result;
55950   return jresult;
55951 }
55952
55953 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_RELEASE_POLICY_get() {
55954   int jresult ;
55955   int result;
55956   {
55957     try
55958     {
55959       result = (int)Dali::Toolkit::ImageVisual::Property::RELEASE_POLICY;
55960     } catch (std::out_of_range& e) {
55961       {
55962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55963       };
55964     } catch (std::exception& e) {
55965       {
55966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55967       };
55968     } catch (...) {
55969       {
55970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55971       };
55972     }
55973   }
55974   jresult = (int)result;
55975   return jresult;
55976 }
55977
55978 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_LOAD_POLICY_get() {
55979   int jresult ;
55980   int result;
55981   {
55982     try
55983     {
55984       result = (int)Dali::Toolkit::ImageVisual::Property::LOAD_POLICY;
55985     } catch (std::out_of_range& e) {
55986       {
55987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
55988       };
55989     } catch (std::exception& e) {
55990       {
55991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
55992       };
55993     } catch (...) {
55994       {
55995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
55996       };
55997     }
55998   }
55999   jresult = (int)result;
56000   return jresult;
56001 }
56002
56003 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_ORIENTATION_CORRECTION_get() {
56004   int jresult ;
56005   int result;
56006   {
56007     try
56008     {
56009       result = (int)Dali::Toolkit::ImageVisual::Property::ORIENTATION_CORRECTION;
56010     } catch (std::out_of_range& e) {
56011       {
56012         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56013       };
56014     } catch (std::exception& e) {
56015       {
56016         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56017       };
56018     } catch (...) {
56019       {
56020         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56021       };
56022     }
56023   }
56024   jresult = (int)result;
56025   return jresult;
56026 }
56027
56028
56029 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_URL_get() {
56030   int jresult ;
56031   int result;
56032   {
56033     try
56034     {
56035       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE;
56036     } catch (std::out_of_range& e) {
56037       {
56038         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56039       };
56040     } catch (std::exception& e) {
56041       {
56042         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56043       };
56044     } catch (...) {
56045       {
56046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56047       };
56048     }
56049   }
56050   jresult = (int)result;
56051   return jresult;
56052 }
56053
56054 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_AUXILIARY_IMAGE_ALPHA_get() {
56055   int jresult ;
56056   int result;
56057   {
56058     try
56059     {
56060       result = (int)Dali::Toolkit::DevelImageVisual::Property::AUXILIARY_IMAGE_ALPHA;
56061     } catch (std::out_of_range& e) {
56062       {
56063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56064       };
56065     } catch (std::exception& e) {
56066       {
56067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56068       };
56069     } catch (...) {
56070       {
56071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56072       };
56073     }
56074   }
56075   jresult = (int)result;
56076   return jresult;
56077 }
56078
56079
56080
56081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_WIDTH_get() {
56082   int jresult ;
56083   int result;
56084
56085   {
56086     try {
56087       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_WIDTH;
56088     } catch (std::out_of_range& e) {
56089       {
56090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56091       };
56092     } catch (std::exception& e) {
56093       {
56094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56095       };
56096     } catch (Dali::DaliException e) {
56097       {
56098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56099       };
56100     } catch (...) {
56101       {
56102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56103       };
56104     }
56105   }
56106
56107   jresult = (int)result;
56108   return jresult;
56109 }
56110
56111
56112 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_DESIRED_HEIGHT_get() {
56113   int jresult ;
56114   int result;
56115
56116   {
56117     try {
56118       result = (int)Dali::Toolkit::ImageVisual::Property::DESIRED_HEIGHT;
56119     } catch (std::out_of_range& e) {
56120       {
56121         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56122       };
56123     } catch (std::exception& e) {
56124       {
56125         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56126       };
56127     } catch (Dali::DaliException e) {
56128       {
56129         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56130       };
56131     } catch (...) {
56132       {
56133         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56134       };
56135     }
56136   }
56137
56138   jresult = (int)result;
56139   return jresult;
56140 }
56141
56142
56143 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_SYNCHRONOUS_LOADING_get() {
56144   int jresult ;
56145   int result;
56146
56147   {
56148     try {
56149       result = (int)Dali::Toolkit::ImageVisual::Property::SYNCHRONOUS_LOADING;
56150     } catch (std::out_of_range& e) {
56151       {
56152         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56153       };
56154     } catch (std::exception& e) {
56155       {
56156         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56157       };
56158     } catch (Dali::DaliException e) {
56159       {
56160         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56161       };
56162     } catch (...) {
56163       {
56164         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56165       };
56166     }
56167   }
56168
56169   jresult = (int)result;
56170   return jresult;
56171 }
56172
56173
56174 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_BORDER_ONLY_get() {
56175   int jresult ;
56176   int result;
56177
56178   {
56179     try {
56180       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER_ONLY;
56181     } catch (std::out_of_range& e) {
56182       {
56183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56184       };
56185     } catch (std::exception& e) {
56186       {
56187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56188       };
56189     } catch (Dali::DaliException e) {
56190       {
56191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56192       };
56193     } catch (...) {
56194       {
56195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56196       };
56197     }
56198   }
56199
56200   jresult = (int)result;
56201   return jresult;
56202 }
56203
56204
56205 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_PIXEL_AREA_get() {
56206   int jresult ;
56207   int result;
56208
56209   {
56210     try {
56211       result = (int)Dali::Toolkit::ImageVisual::Property::PIXEL_AREA;
56212     } catch (std::out_of_range& e) {
56213       {
56214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56215       };
56216     } catch (std::exception& e) {
56217       {
56218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56219       };
56220     } catch (Dali::DaliException e) {
56221       {
56222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56223       };
56224     } catch (...) {
56225       {
56226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56227       };
56228     }
56229   }
56230
56231   jresult = (int)result;
56232   return jresult;
56233 }
56234
56235
56236 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_U_get() {
56237   int jresult ;
56238   int result;
56239
56240   {
56241     try {
56242       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_U;
56243     } catch (std::out_of_range& e) {
56244       {
56245         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56246       };
56247     } catch (std::exception& e) {
56248       {
56249         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56250       };
56251     } catch (Dali::DaliException e) {
56252       {
56253         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56254       };
56255     } catch (...) {
56256       {
56257         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56258       };
56259     }
56260   }
56261
56262   jresult = (int)result;
56263   return jresult;
56264 }
56265
56266
56267 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_IMAGE_VISUAL_WRAP_MODE_V_get() {
56268   int jresult ;
56269   int result;
56270
56271   {
56272     try {
56273       result = (int)Dali::Toolkit::ImageVisual::Property::WRAP_MODE_V;
56274     } catch (std::out_of_range& e) {
56275       {
56276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56277       };
56278     } catch (std::exception& e) {
56279       {
56280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56281       };
56282     } catch (Dali::DaliException e) {
56283       {
56284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56285       };
56286     } catch (...) {
56287       {
56288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56289       };
56290     }
56291   }
56292
56293   jresult = (int)result;
56294   return jresult;
56295 }
56296
56297 SWIGEXPORT int SWIGSTDCALL CSharp_Image_Visual_BORDER_get() {
56298   int jresult ;
56299   int result;
56300
56301   {
56302     try {
56303       result = (int)Dali::Toolkit::ImageVisual::Property::BORDER;
56304     } catch (std::out_of_range& e) {
56305       {
56306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56307       };
56308     } catch (std::exception& e) {
56309       {
56310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56311       };
56312     } catch (...) {
56313       {
56314         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56315       };
56316     }
56317   }
56318   jresult = (int)result;
56319   return jresult;
56320 }
56321
56322 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_OBJECT_URL_get() {
56323   int jresult ;
56324   int result;
56325
56326   {
56327     try {
56328       result = (int)Dali::Toolkit::MeshVisual::Property::OBJECT_URL;
56329     } catch (std::out_of_range& e) {
56330       {
56331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56332       };
56333     } catch (std::exception& e) {
56334       {
56335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56336       };
56337     } catch (Dali::DaliException e) {
56338       {
56339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56340       };
56341     } catch (...) {
56342       {
56343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56344       };
56345     }
56346   }
56347
56348   jresult = (int)result;
56349   return jresult;
56350 }
56351
56352
56353 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_MATERIAL_URL_get() {
56354   int jresult ;
56355   int result;
56356
56357   {
56358     try {
56359       result = (int)Dali::Toolkit::MeshVisual::Property::MATERIAL_URL;
56360     } catch (std::out_of_range& e) {
56361       {
56362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56363       };
56364     } catch (std::exception& e) {
56365       {
56366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56367       };
56368     } catch (Dali::DaliException e) {
56369       {
56370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56371       };
56372     } catch (...) {
56373       {
56374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56375       };
56376     }
56377   }
56378
56379   jresult = (int)result;
56380   return jresult;
56381 }
56382
56383
56384 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_TEXTURES_PATH_get() {
56385   int jresult ;
56386   int result;
56387
56388   {
56389     try {
56390       result = (int)Dali::Toolkit::MeshVisual::Property::TEXTURES_PATH;
56391     } catch (std::out_of_range& e) {
56392       {
56393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56394       };
56395     } catch (std::exception& e) {
56396       {
56397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56398       };
56399     } catch (Dali::DaliException e) {
56400       {
56401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56402       };
56403     } catch (...) {
56404       {
56405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56406       };
56407     }
56408   }
56409
56410   jresult = (int)result;
56411   return jresult;
56412 }
56413
56414
56415 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_SHADING_MODE_get() {
56416   int jresult ;
56417   int result;
56418
56419   {
56420     try {
56421       result = (int)Dali::Toolkit::MeshVisual::Property::SHADING_MODE;
56422     } catch (std::out_of_range& e) {
56423       {
56424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56425       };
56426     } catch (std::exception& e) {
56427       {
56428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56429       };
56430     } catch (Dali::DaliException e) {
56431       {
56432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56433       };
56434     } catch (...) {
56435       {
56436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56437       };
56438     }
56439   }
56440
56441   jresult = (int)result;
56442   return jresult;
56443 }
56444
56445
56446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_MIPMAPPING_get() {
56447   int jresult ;
56448   int result;
56449
56450   {
56451     try {
56452       result = (int)Dali::Toolkit::MeshVisual::Property::USE_MIPMAPPING;
56453     } catch (std::out_of_range& e) {
56454       {
56455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56456       };
56457     } catch (std::exception& e) {
56458       {
56459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56460       };
56461     } catch (Dali::DaliException e) {
56462       {
56463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56464       };
56465     } catch (...) {
56466       {
56467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56468       };
56469     }
56470   }
56471
56472   jresult = (int)result;
56473   return jresult;
56474 }
56475
56476
56477 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_USE_SOFT_NORMALS_get() {
56478   int jresult ;
56479   int result;
56480
56481   {
56482     try {
56483       result = (int)Dali::Toolkit::MeshVisual::Property::USE_SOFT_NORMALS;
56484     } catch (std::out_of_range& e) {
56485       {
56486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56487       };
56488     } catch (std::exception& e) {
56489       {
56490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56491       };
56492     } catch (Dali::DaliException e) {
56493       {
56494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56495       };
56496     } catch (...) {
56497       {
56498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56499       };
56500     }
56501   }
56502
56503   jresult = (int)result;
56504   return jresult;
56505 }
56506
56507
56508 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_MESH_VISUAL_LIGHT_POSITION_get() {
56509   int jresult ;
56510   int result;
56511
56512   {
56513     try {
56514       result = (int)Dali::Toolkit::MeshVisual::Property::LIGHT_POSITION;
56515     } catch (std::out_of_range& e) {
56516       {
56517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56518       };
56519     } catch (std::exception& e) {
56520       {
56521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56522       };
56523     } catch (Dali::DaliException e) {
56524       {
56525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56526       };
56527     } catch (...) {
56528       {
56529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56530       };
56531     }
56532   }
56533
56534   jresult = (int)result;
56535   return jresult;
56536 }
56537
56538
56539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SHAPE_get() {
56540   int jresult ;
56541   int result;
56542
56543   {
56544     try {
56545       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SHAPE;
56546     } catch (std::out_of_range& e) {
56547       {
56548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56549       };
56550     } catch (std::exception& e) {
56551       {
56552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56553       };
56554     } catch (Dali::DaliException e) {
56555       {
56556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56557       };
56558     } catch (...) {
56559       {
56560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56561       };
56562     }
56563   }
56564
56565   jresult = (int)result;
56566   return jresult;
56567 }
56568
56569
56570 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_MIX_COLOR_get() {
56571   int jresult ;
56572   int result;
56573
56574   {
56575     try {
56576       result = (int)Dali::Toolkit::PrimitiveVisual::Property::MIX_COLOR;
56577     } catch (std::out_of_range& e) {
56578       {
56579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56580       };
56581     } catch (std::exception& e) {
56582       {
56583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56584       };
56585     } catch (Dali::DaliException e) {
56586       {
56587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56588       };
56589     } catch (...) {
56590       {
56591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56592       };
56593     }
56594   }
56595
56596   jresult = (int)result;
56597   return jresult;
56598 }
56599
56600
56601 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SLICES_get() {
56602   int jresult ;
56603   int result;
56604
56605   {
56606     try {
56607       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SLICES;
56608     } catch (std::out_of_range& e) {
56609       {
56610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56611       };
56612     } catch (std::exception& e) {
56613       {
56614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56615       };
56616     } catch (Dali::DaliException e) {
56617       {
56618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56619       };
56620     } catch (...) {
56621       {
56622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56623       };
56624     }
56625   }
56626
56627   jresult = (int)result;
56628   return jresult;
56629 }
56630
56631
56632 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_STACKS_get() {
56633   int jresult ;
56634   int result;
56635
56636   {
56637     try {
56638       result = (int)Dali::Toolkit::PrimitiveVisual::Property::STACKS;
56639     } catch (std::out_of_range& e) {
56640       {
56641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56642       };
56643     } catch (std::exception& e) {
56644       {
56645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56646       };
56647     } catch (Dali::DaliException e) {
56648       {
56649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56650       };
56651     } catch (...) {
56652       {
56653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56654       };
56655     }
56656   }
56657
56658   jresult = (int)result;
56659   return jresult;
56660 }
56661
56662
56663 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_TOP_RADIUS_get() {
56664   int jresult ;
56665   int result;
56666
56667   {
56668     try {
56669       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_TOP_RADIUS;
56670     } catch (std::out_of_range& e) {
56671       {
56672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56673       };
56674     } catch (std::exception& e) {
56675       {
56676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56677       };
56678     } catch (Dali::DaliException e) {
56679       {
56680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56681       };
56682     } catch (...) {
56683       {
56684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56685       };
56686     }
56687   }
56688
56689   jresult = (int)result;
56690   return jresult;
56691 }
56692
56693
56694 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_BOTTOM_RADIUS_get() {
56695   int jresult ;
56696   int result;
56697
56698   {
56699     try {
56700       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_BOTTOM_RADIUS;
56701     } catch (std::out_of_range& e) {
56702       {
56703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56704       };
56705     } catch (std::exception& e) {
56706       {
56707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56708       };
56709     } catch (Dali::DaliException e) {
56710       {
56711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56712       };
56713     } catch (...) {
56714       {
56715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56716       };
56717     }
56718   }
56719
56720   jresult = (int)result;
56721   return jresult;
56722 }
56723
56724
56725 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_HEIGHT_get() {
56726   int jresult ;
56727   int result;
56728
56729   {
56730     try {
56731       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_HEIGHT;
56732     } catch (std::out_of_range& e) {
56733       {
56734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56735       };
56736     } catch (std::exception& e) {
56737       {
56738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56739       };
56740     } catch (Dali::DaliException e) {
56741       {
56742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56743       };
56744     } catch (...) {
56745       {
56746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56747       };
56748     }
56749   }
56750
56751   jresult = (int)result;
56752   return jresult;
56753 }
56754
56755
56756 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_RADIUS_get() {
56757   int jresult ;
56758   int result;
56759
56760   {
56761     try {
56762       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_RADIUS;
56763     } catch (std::out_of_range& e) {
56764       {
56765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56766       };
56767     } catch (std::exception& e) {
56768       {
56769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56770       };
56771     } catch (Dali::DaliException e) {
56772       {
56773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56774       };
56775     } catch (...) {
56776       {
56777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56778       };
56779     }
56780   }
56781
56782   jresult = (int)result;
56783   return jresult;
56784 }
56785
56786
56787 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_SCALE_DIMENSIONS_get() {
56788   int jresult ;
56789   int result;
56790
56791   {
56792     try {
56793       result = (int)Dali::Toolkit::PrimitiveVisual::Property::SCALE_DIMENSIONS;
56794     } catch (std::out_of_range& e) {
56795       {
56796         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
56797       };
56798     } catch (std::exception& e) {
56799       {
56800         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
56801       };
56802     } catch (Dali::DaliException e) {
56803       {
56804         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
56805       };
56806     } catch (...) {
56807       {
56808         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
56809       };
56810     }
56811   }
56812
56813   jresult = (int)result;
56814   return jresult;
56815 }
56816
56817
56818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PRIMITIVE_VISUAL_BEVEL_PERCENTAGE_get() {
56819   int jresult ;
56820   int result;
56821
56822   {
56823     try {
56824       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_PERCENTAGE;
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_PRIMITIVE_VISUAL_BEVEL_SMOOTHNESS_get() {
56850   int jresult ;
56851   int result;
56852
56853   {
56854     try {
56855       result = (int)Dali::Toolkit::PrimitiveVisual::Property::BEVEL_SMOOTHNESS;
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_PRIMITIVE_VISUAL_LIGHT_POSITION_get() {
56881   int jresult ;
56882   int result;
56883
56884   {
56885     try {
56886       result = (int)Dali::Toolkit::PrimitiveVisual::Property::LIGHT_POSITION;
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_TEXT_VISUAL_TEXT_get() {
56912   int jresult ;
56913   int result;
56914
56915   {
56916     try {
56917       result = (int)Dali::Toolkit::TextVisual::Property::TEXT;
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_TEXT_VISUAL_FONT_FAMILY_get() {
56943   int jresult ;
56944   int result;
56945
56946   {
56947     try {
56948       result = (int)Dali::Toolkit::TextVisual::Property::FONT_FAMILY;
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_TEXT_VISUAL_FONT_STYLE_get() {
56974   int jresult ;
56975   int result;
56976
56977   {
56978     try {
56979       result = (int)Dali::Toolkit::TextVisual::Property::FONT_STYLE;
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_TEXT_VISUAL_POINT_SIZE_get() {
57005   int jresult ;
57006   int result;
57007
57008   {
57009     try {
57010       result = (int)Dali::Toolkit::TextVisual::Property::POINT_SIZE;
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_TEXT_VISUAL_MULTI_LINE_get() {
57036   int jresult ;
57037   int result;
57038
57039   {
57040     try {
57041       result = (int)Dali::Toolkit::TextVisual::Property::MULTI_LINE;
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_TEXT_VISUAL_HORIZONTAL_ALIGNMENT_get() {
57067   int jresult ;
57068   int result;
57069
57070   {
57071     try {
57072       result = (int)Dali::Toolkit::TextVisual::Property::HORIZONTAL_ALIGNMENT;
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_TEXT_VISUAL_VERTICAL_ALIGNMENT_get() {
57098   int jresult ;
57099   int result;
57100
57101   {
57102     try {
57103       result = (int)Dali::Toolkit::TextVisual::Property::VERTICAL_ALIGNMENT;
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_TEXT_VISUAL_TEXT_COLOR_get() {
57129   int jresult ;
57130   int result;
57131
57132   {
57133     try {
57134       result = (int)Dali::Toolkit::TextVisual::Property::TEXT_COLOR;
57135     } catch (std::out_of_range& e) {
57136       {
57137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57138       };
57139     } catch (std::exception& e) {
57140       {
57141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57142       };
57143     } catch (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_TEXT_VISUAL_ENABLE_MARKUP_get() {
57160   int jresult ;
57161   int result;
57162
57163   {
57164     try {
57165       result = (int)Dali::Toolkit::TextVisual::Property::ENABLE_MARKUP;
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 void * SWIGSTDCALL CSharp_Dali_new_Builder() {
57191   void * jresult ;
57192   Dali::Toolkit::Builder *result = 0 ;
57193
57194   {
57195     try {
57196       result = (Dali::Toolkit::Builder *)new Dali::Toolkit::Builder();
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 = (void *)result;
57217   return jresult;
57218 }
57219
57220
57221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_New() {
57222   void * jresult ;
57223   Dali::Toolkit::Builder result;
57224
57225   {
57226     try {
57227       result = Dali::Toolkit::Builder::New();
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 = new Dali::Toolkit::Builder((const Dali::Toolkit::Builder &)result);
57248   return jresult;
57249 }
57250
57251
57252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Builder(void * jarg1) {
57253   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57254
57255   arg1 = (Dali::Toolkit::Builder *)jarg1;
57256   {
57257     try {
57258       delete arg1;
57259     } catch (std::out_of_range& e) {
57260       {
57261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57262       };
57263     } catch (std::exception& e) {
57264       {
57265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57266       };
57267     } catch (Dali::DaliException e) {
57268       {
57269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57270       };
57271     } catch (...) {
57272       {
57273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57274       };
57275     }
57276   }
57277
57278 }
57279
57280
57281 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_0(void * jarg1, char * jarg2, int jarg3) {
57282   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57283   std::string *arg2 = 0 ;
57284   Dali::Toolkit::Builder::UIFormat arg3 ;
57285
57286   arg1 = (Dali::Toolkit::Builder *)jarg1;
57287   if (!jarg2) {
57288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57289     return ;
57290   }
57291   std::string arg2_str(jarg2);
57292   arg2 = &arg2_str;
57293   arg3 = (Dali::Toolkit::Builder::UIFormat)jarg3;
57294   {
57295     try {
57296       (arg1)->LoadFromString((std::string const &)*arg2,arg3);
57297     } catch (std::out_of_range& e) {
57298       {
57299         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57300       };
57301     } catch (std::exception& e) {
57302       {
57303         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57304       };
57305     } catch (Dali::DaliException e) {
57306       {
57307         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57308       };
57309     } catch (...) {
57310       {
57311         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57312       };
57313     }
57314   }
57315
57316
57317   //argout typemap for const std::string&
57318
57319 }
57320
57321
57322 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_LoadFromString__SWIG_1(void * jarg1, char * jarg2) {
57323   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57324   std::string *arg2 = 0 ;
57325
57326   arg1 = (Dali::Toolkit::Builder *)jarg1;
57327   if (!jarg2) {
57328     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57329     return ;
57330   }
57331   std::string arg2_str(jarg2);
57332   arg2 = &arg2_str;
57333   {
57334     try {
57335       (arg1)->LoadFromString((std::string const &)*arg2);
57336     } catch (std::out_of_range& e) {
57337       {
57338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57339       };
57340     } catch (std::exception& e) {
57341       {
57342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57343       };
57344     } catch (Dali::DaliException e) {
57345       {
57346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57347       };
57348     } catch (...) {
57349       {
57350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57351       };
57352     }
57353   }
57354
57355
57356   //argout typemap for const std::string&
57357
57358 }
57359
57360
57361 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstants(void * jarg1, void * jarg2) {
57362   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57363   Dali::Property::Map *arg2 = 0 ;
57364
57365   arg1 = (Dali::Toolkit::Builder *)jarg1;
57366   arg2 = (Dali::Property::Map *)jarg2;
57367   if (!arg2) {
57368     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57369     return ;
57370   }
57371   {
57372     try {
57373       (arg1)->AddConstants((Dali::Property::Map const &)*arg2);
57374     } catch (std::out_of_range& e) {
57375       {
57376         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57377       };
57378     } catch (std::exception& e) {
57379       {
57380         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57381       };
57382     } catch (Dali::DaliException e) {
57383       {
57384         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57385       };
57386     } catch (...) {
57387       {
57388         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57389       };
57390     }
57391   }
57392
57393 }
57394
57395
57396 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddConstant(void * jarg1, char * jarg2, void * jarg3) {
57397   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57398   std::string *arg2 = 0 ;
57399   Dali::Property::Value *arg3 = 0 ;
57400
57401   arg1 = (Dali::Toolkit::Builder *)jarg1;
57402   if (!jarg2) {
57403     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57404     return ;
57405   }
57406   std::string arg2_str(jarg2);
57407   arg2 = &arg2_str;
57408   arg3 = (Dali::Property::Value *)jarg3;
57409   if (!arg3) {
57410     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
57411     return ;
57412   }
57413   {
57414     try {
57415       (arg1)->AddConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
57416     } catch (std::out_of_range& e) {
57417       {
57418         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57419       };
57420     } catch (std::exception& e) {
57421       {
57422         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57423       };
57424     } catch (Dali::DaliException e) {
57425       {
57426         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57427       };
57428     } catch (...) {
57429       {
57430         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57431       };
57432     }
57433   }
57434
57435
57436   //argout typemap for const std::string&
57437
57438 }
57439
57440
57441 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstants(void * jarg1) {
57442   void * jresult ;
57443   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57444   Dali::Property::Map *result = 0 ;
57445
57446   arg1 = (Dali::Toolkit::Builder *)jarg1;
57447   {
57448     try {
57449       result = (Dali::Property::Map *) &((Dali::Toolkit::Builder const *)arg1)->GetConstants();
57450     } catch (std::out_of_range& e) {
57451       {
57452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57453       };
57454     } catch (std::exception& e) {
57455       {
57456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57457       };
57458     } catch (Dali::DaliException e) {
57459       {
57460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57461       };
57462     } catch (...) {
57463       {
57464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57465       };
57466     }
57467   }
57468
57469   jresult = (void *)result;
57470   return jresult;
57471 }
57472
57473
57474 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetConstant(void * jarg1, char * jarg2) {
57475   void * jresult ;
57476   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57477   std::string *arg2 = 0 ;
57478   Dali::Property::Value *result = 0 ;
57479
57480   arg1 = (Dali::Toolkit::Builder *)jarg1;
57481   if (!jarg2) {
57482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57483     return 0;
57484   }
57485   std::string arg2_str(jarg2);
57486   arg2 = &arg2_str;
57487   {
57488     try {
57489       result = (Dali::Property::Value *) &((Dali::Toolkit::Builder const *)arg1)->GetConstant((std::string const &)*arg2);
57490     } catch (std::out_of_range& e) {
57491       {
57492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57493       };
57494     } catch (std::exception& e) {
57495       {
57496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57497       };
57498     } catch (Dali::DaliException e) {
57499       {
57500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57501       };
57502     } catch (...) {
57503       {
57504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57505       };
57506     }
57507   }
57508
57509   jresult = (void *)result;
57510
57511   //argout typemap for const std::string&
57512
57513   return jresult;
57514 }
57515
57516
57517 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_0(void * jarg1, char * jarg2) {
57518   void * jresult ;
57519   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57520   std::string *arg2 = 0 ;
57521   Dali::Animation result;
57522
57523   arg1 = (Dali::Toolkit::Builder *)jarg1;
57524   if (!jarg2) {
57525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57526     return 0;
57527   }
57528   std::string arg2_str(jarg2);
57529   arg2 = &arg2_str;
57530   {
57531     try {
57532       result = (arg1)->CreateAnimation((std::string const &)*arg2);
57533     } catch (std::out_of_range& e) {
57534       {
57535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57536       };
57537     } catch (std::exception& e) {
57538       {
57539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57540       };
57541     } catch (Dali::DaliException e) {
57542       {
57543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57544       };
57545     } catch (...) {
57546       {
57547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57548       };
57549     }
57550   }
57551
57552   jresult = new Dali::Animation((const Dali::Animation &)result);
57553
57554   //argout typemap for const std::string&
57555
57556   return jresult;
57557 }
57558
57559
57560 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57561   void * jresult ;
57562   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57563   std::string *arg2 = 0 ;
57564   Dali::Property::Map *arg3 = 0 ;
57565   Dali::Animation result;
57566
57567   arg1 = (Dali::Toolkit::Builder *)jarg1;
57568   if (!jarg2) {
57569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57570     return 0;
57571   }
57572   std::string arg2_str(jarg2);
57573   arg2 = &arg2_str;
57574   arg3 = (Dali::Property::Map *)jarg3;
57575   if (!arg3) {
57576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57577     return 0;
57578   }
57579   {
57580     try {
57581       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57582     } catch (std::out_of_range& e) {
57583       {
57584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57585       };
57586     } catch (std::exception& e) {
57587       {
57588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57589       };
57590     } catch (Dali::DaliException e) {
57591       {
57592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57593       };
57594     } catch (...) {
57595       {
57596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57597       };
57598     }
57599   }
57600
57601   jresult = new Dali::Animation((const Dali::Animation &)result);
57602
57603   //argout typemap for const std::string&
57604
57605   return jresult;
57606 }
57607
57608
57609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
57610   void * jresult ;
57611   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57612   std::string *arg2 = 0 ;
57613   Dali::Actor arg3 ;
57614   Dali::Actor *argp3 ;
57615   Dali::Animation result;
57616
57617   arg1 = (Dali::Toolkit::Builder *)jarg1;
57618   if (!jarg2) {
57619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57620     return 0;
57621   }
57622   std::string arg2_str(jarg2);
57623   arg2 = &arg2_str;
57624   argp3 = (Dali::Actor *)jarg3;
57625   if (!argp3) {
57626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57627     return 0;
57628   }
57629   arg3 = *argp3;
57630   {
57631     try {
57632       result = (arg1)->CreateAnimation((std::string const &)*arg2,arg3);
57633     } catch (std::out_of_range& e) {
57634       {
57635         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57636       };
57637     } catch (std::exception& e) {
57638       {
57639         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57640       };
57641     } catch (Dali::DaliException e) {
57642       {
57643         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57644       };
57645     } catch (...) {
57646       {
57647         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57648       };
57649     }
57650   }
57651
57652   jresult = new Dali::Animation((const Dali::Animation &)result);
57653
57654   //argout typemap for const std::string&
57655
57656   return jresult;
57657 }
57658
57659
57660 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateAnimation__SWIG_3(void * jarg1, char * jarg2, void * jarg3, void * jarg4) {
57661   void * jresult ;
57662   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57663   std::string *arg2 = 0 ;
57664   Dali::Property::Map *arg3 = 0 ;
57665   Dali::Actor arg4 ;
57666   Dali::Actor *argp4 ;
57667   Dali::Animation result;
57668
57669   arg1 = (Dali::Toolkit::Builder *)jarg1;
57670   if (!jarg2) {
57671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57672     return 0;
57673   }
57674   std::string arg2_str(jarg2);
57675   arg2 = &arg2_str;
57676   arg3 = (Dali::Property::Map *)jarg3;
57677   if (!arg3) {
57678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57679     return 0;
57680   }
57681   argp4 = (Dali::Actor *)jarg4;
57682   if (!argp4) {
57683     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57684     return 0;
57685   }
57686   arg4 = *argp4;
57687   {
57688     try {
57689       result = (arg1)->CreateAnimation((std::string const &)*arg2,(Dali::Property::Map const &)*arg3,arg4);
57690     } catch (std::out_of_range& e) {
57691       {
57692         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57693       };
57694     } catch (std::exception& e) {
57695       {
57696         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57697       };
57698     } catch (Dali::DaliException e) {
57699       {
57700         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57701       };
57702     } catch (...) {
57703       {
57704         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57705       };
57706     }
57707   }
57708
57709   jresult = new Dali::Animation((const Dali::Animation &)result);
57710
57711   //argout typemap for const std::string&
57712
57713   return jresult;
57714 }
57715
57716
57717 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_0(void * jarg1, char * jarg2) {
57718   void * jresult ;
57719   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57720   std::string *arg2 = 0 ;
57721   Dali::BaseHandle result;
57722
57723   arg1 = (Dali::Toolkit::Builder *)jarg1;
57724   if (!jarg2) {
57725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57726     return 0;
57727   }
57728   std::string arg2_str(jarg2);
57729   arg2 = &arg2_str;
57730   {
57731     try {
57732       result = (arg1)->Create((std::string const &)*arg2);
57733     } catch (std::out_of_range& e) {
57734       {
57735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57736       };
57737     } catch (std::exception& e) {
57738       {
57739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57740       };
57741     } catch (Dali::DaliException e) {
57742       {
57743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57744       };
57745     } catch (...) {
57746       {
57747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57748       };
57749     }
57750   }
57751
57752   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57753
57754   //argout typemap for const std::string&
57755
57756   return jresult;
57757 }
57758
57759
57760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_Create__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57761   void * jresult ;
57762   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57763   std::string *arg2 = 0 ;
57764   Dali::Property::Map *arg3 = 0 ;
57765   Dali::BaseHandle result;
57766
57767   arg1 = (Dali::Toolkit::Builder *)jarg1;
57768   if (!jarg2) {
57769     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57770     return 0;
57771   }
57772   std::string arg2_str(jarg2);
57773   arg2 = &arg2_str;
57774   arg3 = (Dali::Property::Map *)jarg3;
57775   if (!arg3) {
57776     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
57777     return 0;
57778   }
57779   {
57780     try {
57781       result = (arg1)->Create((std::string const &)*arg2,(Dali::Property::Map const &)*arg3);
57782     } catch (std::out_of_range& e) {
57783       {
57784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57785       };
57786     } catch (std::exception& e) {
57787       {
57788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57789       };
57790     } catch (Dali::DaliException e) {
57791       {
57792         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57793       };
57794     } catch (...) {
57795       {
57796         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57797       };
57798     }
57799   }
57800
57801   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57802
57803   //argout typemap for const std::string&
57804
57805   return jresult;
57806 }
57807
57808
57809 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_CreateFromJson(void * jarg1, char * jarg2) {
57810   void * jresult ;
57811   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57812   std::string *arg2 = 0 ;
57813   Dali::BaseHandle result;
57814
57815   arg1 = (Dali::Toolkit::Builder *)jarg1;
57816   if (!jarg2) {
57817     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57818     return 0;
57819   }
57820   std::string arg2_str(jarg2);
57821   arg2 = &arg2_str;
57822   {
57823     try {
57824       result = (arg1)->CreateFromJson((std::string const &)*arg2);
57825     } catch (std::out_of_range& e) {
57826       {
57827         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57828       };
57829     } catch (std::exception& e) {
57830       {
57831         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57832       };
57833     } catch (Dali::DaliException e) {
57834       {
57835         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57836       };
57837     } catch (...) {
57838       {
57839         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57840       };
57841     }
57842   }
57843
57844   jresult = new Dali::BaseHandle((const Dali::BaseHandle &)result);
57845
57846   //argout typemap for const std::string&
57847
57848   return jresult;
57849 }
57850
57851
57852 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyStyle(void * jarg1, char * jarg2, void * jarg3) {
57853   unsigned int jresult ;
57854   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57855   std::string *arg2 = 0 ;
57856   Dali::Handle *arg3 = 0 ;
57857   bool result;
57858
57859   arg1 = (Dali::Toolkit::Builder *)jarg1;
57860   if (!jarg2) {
57861     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57862     return 0;
57863   }
57864   std::string arg2_str(jarg2);
57865   arg2 = &arg2_str;
57866   arg3 = (Dali::Handle *)jarg3;
57867   if (!arg3) {
57868     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57869     return 0;
57870   }
57871   {
57872     try {
57873       result = (bool)(arg1)->ApplyStyle((std::string const &)*arg2,*arg3);
57874     } catch (std::out_of_range& e) {
57875       {
57876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57877       };
57878     } catch (std::exception& e) {
57879       {
57880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57881       };
57882     } catch (Dali::DaliException e) {
57883       {
57884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57885       };
57886     } catch (...) {
57887       {
57888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57889       };
57890     }
57891   }
57892
57893   jresult = result;
57894
57895   //argout typemap for const std::string&
57896
57897   return jresult;
57898 }
57899
57900
57901 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Builder_ApplyFromJson(void * jarg1, void * jarg2, char * jarg3) {
57902   unsigned int jresult ;
57903   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57904   Dali::Handle *arg2 = 0 ;
57905   std::string *arg3 = 0 ;
57906   bool result;
57907
57908   arg1 = (Dali::Toolkit::Builder *)jarg1;
57909   arg2 = (Dali::Handle *)jarg2;
57910   if (!arg2) {
57911     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Handle & type is null", 0);
57912     return 0;
57913   }
57914   if (!jarg3) {
57915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57916     return 0;
57917   }
57918   std::string arg3_str(jarg3);
57919   arg3 = &arg3_str;
57920   {
57921     try {
57922       result = (bool)(arg1)->ApplyFromJson(*arg2,(std::string const &)*arg3);
57923     } catch (std::out_of_range& e) {
57924       {
57925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
57926       };
57927     } catch (std::exception& e) {
57928       {
57929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
57930       };
57931     } catch (Dali::DaliException e) {
57932       {
57933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
57934       };
57935     } catch (...) {
57936       {
57937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
57938       };
57939     }
57940   }
57941
57942   jresult = result;
57943
57944   //argout typemap for const std::string&
57945
57946   return jresult;
57947 }
57948
57949
57950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_0(void * jarg1, void * jarg2) {
57951   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57952   Dali::Actor arg2 ;
57953   Dali::Actor *argp2 ;
57954
57955   arg1 = (Dali::Toolkit::Builder *)jarg1;
57956   argp2 = (Dali::Actor *)jarg2;
57957   if (!argp2) {
57958     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
57959     return ;
57960   }
57961   arg2 = *argp2;
57962   {
57963     try {
57964       (arg1)->AddActors(arg2);
57965     } catch (std::out_of_range& e) {
57966       {
57967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
57968       };
57969     } catch (std::exception& e) {
57970       {
57971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
57972       };
57973     } catch (Dali::DaliException e) {
57974       {
57975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
57976       };
57977     } catch (...) {
57978       {
57979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
57980       };
57981     }
57982   }
57983
57984 }
57985
57986
57987 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_AddActors__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
57988   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
57989   std::string *arg2 = 0 ;
57990   Dali::Actor arg3 ;
57991   Dali::Actor *argp3 ;
57992
57993   arg1 = (Dali::Toolkit::Builder *)jarg1;
57994   if (!jarg2) {
57995     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
57996     return ;
57997   }
57998   std::string arg2_str(jarg2);
57999   arg2 = &arg2_str;
58000   argp3 = (Dali::Actor *)jarg3;
58001   if (!argp3) {
58002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
58003     return ;
58004   }
58005   arg3 = *argp3;
58006   {
58007     try {
58008       (arg1)->AddActors((std::string const &)*arg2,arg3);
58009     } catch (std::out_of_range& e) {
58010       {
58011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58012       };
58013     } catch (std::exception& e) {
58014       {
58015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58016       };
58017     } catch (Dali::DaliException e) {
58018       {
58019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58020       };
58021     } catch (...) {
58022       {
58023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58024       };
58025     }
58026   }
58027
58028
58029   //argout typemap for const std::string&
58030
58031 }
58032
58033
58034 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Builder_CreateRenderTask(void * jarg1, char * jarg2) {
58035   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58036   std::string *arg2 = 0 ;
58037
58038   arg1 = (Dali::Toolkit::Builder *)jarg1;
58039   if (!jarg2) {
58040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58041     return ;
58042   }
58043   std::string arg2_str(jarg2);
58044   arg2 = &arg2_str;
58045   {
58046     try {
58047       (arg1)->CreateRenderTask((std::string const &)*arg2);
58048     } catch (std::out_of_range& e) {
58049       {
58050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58051       };
58052     } catch (std::exception& e) {
58053       {
58054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58055       };
58056     } catch (Dali::DaliException e) {
58057       {
58058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58059       };
58060     } catch (...) {
58061       {
58062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58063       };
58064     }
58065   }
58066
58067
58068   //argout typemap for const std::string&
58069
58070 }
58071
58072
58073 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPath(void * jarg1, char * jarg2) {
58074   void * jresult ;
58075   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58076   std::string *arg2 = 0 ;
58077   Dali::Path result;
58078
58079   arg1 = (Dali::Toolkit::Builder *)jarg1;
58080   if (!jarg2) {
58081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58082     return 0;
58083   }
58084   std::string arg2_str(jarg2);
58085   arg2 = &arg2_str;
58086   {
58087     try {
58088       result = (arg1)->GetPath((std::string const &)*arg2);
58089     } catch (std::out_of_range& e) {
58090       {
58091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58092       };
58093     } catch (std::exception& e) {
58094       {
58095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58096       };
58097     } catch (Dali::DaliException e) {
58098       {
58099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58100       };
58101     } catch (...) {
58102       {
58103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58104       };
58105     }
58106   }
58107
58108   jresult = new Dali::Path((const Dali::Path &)result);
58109
58110   //argout typemap for const std::string&
58111
58112   return jresult;
58113 }
58114
58115
58116 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetPathConstrainer(void * jarg1, char * jarg2) {
58117   void * jresult ;
58118   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58119   std::string *arg2 = 0 ;
58120   Dali::PathConstrainer result;
58121
58122   arg1 = (Dali::Toolkit::Builder *)jarg1;
58123   if (!jarg2) {
58124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
58125     return 0;
58126   }
58127   std::string arg2_str(jarg2);
58128   arg2 = &arg2_str;
58129   {
58130     try {
58131       result = (arg1)->GetPathConstrainer((std::string const &)*arg2);
58132     } catch (std::out_of_range& e) {
58133       {
58134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58135       };
58136     } catch (std::exception& e) {
58137       {
58138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58139       };
58140     } catch (Dali::DaliException e) {
58141       {
58142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58143       };
58144     } catch (...) {
58145       {
58146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58147       };
58148     }
58149   }
58150
58151   jresult = new Dali::PathConstrainer((const Dali::PathConstrainer &)result);
58152
58153   //argout typemap for const std::string&
58154
58155   return jresult;
58156 }
58157
58158
58159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_GetLinearConstrainer(void * jarg1, char * jarg2) {
58160   void * jresult ;
58161   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58162   std::string *arg2 = 0 ;
58163   Dali::LinearConstrainer 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   {
58173     try {
58174       result = (arg1)->GetLinearConstrainer((std::string const &)*arg2);
58175     } catch (std::out_of_range& e) {
58176       {
58177         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58178       };
58179     } catch (std::exception& e) {
58180       {
58181         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58182       };
58183     } catch (Dali::DaliException e) {
58184       {
58185         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58186       };
58187     } catch (...) {
58188       {
58189         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58190       };
58191     }
58192   }
58193
58194   jresult = new Dali::LinearConstrainer((const Dali::LinearConstrainer &)result);
58195
58196   //argout typemap for const std::string&
58197
58198   return jresult;
58199 }
58200
58201
58202 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Builder_QuitSignal(void * jarg1) {
58203   void * jresult ;
58204   Dali::Toolkit::Builder *arg1 = (Dali::Toolkit::Builder *) 0 ;
58205   Dali::Toolkit::Builder::BuilderSignalType *result = 0 ;
58206
58207   arg1 = (Dali::Toolkit::Builder *)jarg1;
58208   {
58209     try {
58210       result = (Dali::Toolkit::Builder::BuilderSignalType *) &(arg1)->QuitSignal();
58211     } catch (std::out_of_range& e) {
58212       {
58213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58214       };
58215     } catch (std::exception& e) {
58216       {
58217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58218       };
58219     } catch (Dali::DaliException e) {
58220       {
58221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58222       };
58223     } catch (...) {
58224       {
58225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58226       };
58227     }
58228   }
58229
58230   jresult = (void *)result;
58231   return jresult;
58232 }
58233
58234
58235 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_0() {
58236   void * jresult ;
58237   Dali::Toolkit::TransitionData *result = 0 ;
58238
58239   {
58240     try {
58241       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData();
58242     } catch (std::out_of_range& e) {
58243       {
58244         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58245       };
58246     } catch (std::exception& e) {
58247       {
58248         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58249       };
58250     } catch (Dali::DaliException e) {
58251       {
58252         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58253       };
58254     } catch (...) {
58255       {
58256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58257       };
58258     }
58259   }
58260
58261   jresult = (void *)result;
58262   return jresult;
58263 }
58264
58265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TransitionData(void * jarg1) {
58266   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58267
58268   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58269   {
58270     try {
58271       delete arg1;
58272     } catch (std::out_of_range& e) {
58273       {
58274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
58275       };
58276     } catch (std::exception& e) {
58277       {
58278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
58279       };
58280     } catch (Dali::DaliException e) {
58281       {
58282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
58283       };
58284     } catch (...) {
58285       {
58286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
58287       };
58288     }
58289   }
58290
58291 }
58292
58293
58294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_0(void * jarg1) {
58295   void * jresult ;
58296   Dali::Property::Map *arg1 = 0 ;
58297   Dali::Toolkit::TransitionData result;
58298
58299   arg1 = (Dali::Property::Map *)jarg1;
58300   if (!arg1) {
58301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
58302     return 0;
58303   }
58304   {
58305     try {
58306       result = Dali::Toolkit::TransitionData::New((Dali::Property::Map const &)*arg1);
58307     } catch (std::out_of_range& e) {
58308       {
58309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58310       };
58311     } catch (std::exception& e) {
58312       {
58313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58314       };
58315     } catch (Dali::DaliException e) {
58316       {
58317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58318       };
58319     } catch (...) {
58320       {
58321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58322       };
58323     }
58324   }
58325
58326   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58327   return jresult;
58328 }
58329
58330
58331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_New__SWIG_1(void * jarg1) {
58332   void * jresult ;
58333   Dali::Property::Array *arg1 = 0 ;
58334   Dali::Toolkit::TransitionData result;
58335
58336   arg1 = (Dali::Property::Array *)jarg1;
58337   if (!arg1) {
58338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Array const & type is null", 0);
58339     return 0;
58340   }
58341   {
58342     try {
58343       result = Dali::Toolkit::TransitionData::New((Dali::Property::Array const &)*arg1);
58344     } catch (std::out_of_range& e) {
58345       {
58346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58347       };
58348     } catch (std::exception& e) {
58349       {
58350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58351       };
58352     } catch (Dali::DaliException e) {
58353       {
58354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58355       };
58356     } catch (...) {
58357       {
58358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58359       };
58360     }
58361   }
58362
58363   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58364   return jresult;
58365 }
58366
58367
58368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_DownCast(void * jarg1) {
58369   void * jresult ;
58370   Dali::BaseHandle arg1 ;
58371   Dali::BaseHandle *argp1 ;
58372   Dali::Toolkit::TransitionData result;
58373
58374   argp1 = (Dali::BaseHandle *)jarg1;
58375   if (!argp1) {
58376     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
58377     return 0;
58378   }
58379   arg1 = *argp1;
58380   {
58381     try {
58382       result = Dali::Toolkit::TransitionData::DownCast(arg1);
58383     } catch (std::out_of_range& e) {
58384       {
58385         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58386       };
58387     } catch (std::exception& e) {
58388       {
58389         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58390       };
58391     } catch (Dali::DaliException e) {
58392       {
58393         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58394       };
58395     } catch (...) {
58396       {
58397         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58398       };
58399     }
58400   }
58401
58402   jresult = new Dali::Toolkit::TransitionData((const Dali::Toolkit::TransitionData &)result);
58403   return jresult;
58404 }
58405
58406
58407 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TransitionData__SWIG_1(void * jarg1) {
58408   void * jresult ;
58409   Dali::Toolkit::TransitionData *arg1 = 0 ;
58410   Dali::Toolkit::TransitionData *result = 0 ;
58411
58412   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58413   if (!arg1) {
58414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58415     return 0;
58416   }
58417   {
58418     try {
58419       result = (Dali::Toolkit::TransitionData *)new Dali::Toolkit::TransitionData((Dali::Toolkit::TransitionData const &)*arg1);
58420     } catch (std::out_of_range& e) {
58421       {
58422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58423       };
58424     } catch (std::exception& e) {
58425       {
58426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58427       };
58428     } catch (Dali::DaliException e) {
58429       {
58430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58431       };
58432     } catch (...) {
58433       {
58434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58435       };
58436     }
58437   }
58438
58439   jresult = (void *)result;
58440   return jresult;
58441 }
58442
58443
58444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_Assign(void * jarg1, void * jarg2) {
58445   void * jresult ;
58446   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58447   Dali::Toolkit::TransitionData *arg2 = 0 ;
58448   Dali::Toolkit::TransitionData *result = 0 ;
58449
58450   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58451   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
58452   if (!arg2) {
58453     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
58454     return 0;
58455   }
58456   {
58457     try {
58458       result = (Dali::Toolkit::TransitionData *) &(arg1)->operator =((Dali::Toolkit::TransitionData const &)*arg2);
58459     } catch (std::out_of_range& e) {
58460       {
58461         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58462       };
58463     } catch (std::exception& e) {
58464       {
58465         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58466       };
58467     } catch (Dali::DaliException e) {
58468       {
58469         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58470       };
58471     } catch (...) {
58472       {
58473         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58474       };
58475     }
58476   }
58477
58478   jresult = (void *)result;
58479   return jresult;
58480 }
58481
58482
58483 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_TransitionData_Count(void * jarg1) {
58484   unsigned long jresult ;
58485   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58486   size_t result;
58487
58488   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58489   {
58490     try {
58491       result = ((Dali::Toolkit::TransitionData const *)arg1)->Count();
58492     } catch (std::out_of_range& e) {
58493       {
58494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58495       };
58496     } catch (std::exception& e) {
58497       {
58498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58499       };
58500     } catch (Dali::DaliException e) {
58501       {
58502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58503       };
58504     } catch (...) {
58505       {
58506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58507       };
58508     }
58509   }
58510
58511   jresult = (unsigned long)result;
58512   return jresult;
58513 }
58514
58515
58516 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TransitionData_GetAnimatorAt(void * jarg1, unsigned long jarg2) {
58517   void * jresult ;
58518   Dali::Toolkit::TransitionData *arg1 = (Dali::Toolkit::TransitionData *) 0 ;
58519   size_t arg2 ;
58520   Dali::Property::Map result;
58521
58522   arg1 = (Dali::Toolkit::TransitionData *)jarg1;
58523   arg2 = (size_t)jarg2;
58524   {
58525     try {
58526       result = (arg1)->GetAnimatorAt(arg2);
58527     } catch (std::out_of_range& e) {
58528       {
58529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58530       };
58531     } catch (std::exception& e) {
58532       {
58533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58534       };
58535     } catch (Dali::DaliException e) {
58536       {
58537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58538       };
58539     } catch (...) {
58540       {
58541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58542       };
58543     }
58544   }
58545
58546   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
58547   return jresult;
58548 }
58549
58550
58551 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_CONTENT_get() {
58552   int jresult ;
58553   int result;
58554
58555   {
58556     try {
58557       result = (int)Dali::Toolkit::Tooltip::Property::CONTENT;
58558     } catch (std::out_of_range& e) {
58559       {
58560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58561       };
58562     } catch (std::exception& e) {
58563       {
58564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58565       };
58566     } catch (Dali::DaliException e) {
58567       {
58568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58569       };
58570     } catch (...) {
58571       {
58572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58573       };
58574     }
58575   }
58576
58577   jresult = (int)result;
58578   return jresult;
58579 }
58580
58581
58582 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_LAYOUT_get() {
58583   int jresult ;
58584   int result;
58585
58586   {
58587     try {
58588       result = (int)Dali::Toolkit::Tooltip::Property::LAYOUT;
58589     } catch (std::out_of_range& e) {
58590       {
58591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58592       };
58593     } catch (std::exception& e) {
58594       {
58595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58596       };
58597     } catch (Dali::DaliException e) {
58598       {
58599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58600       };
58601     } catch (...) {
58602       {
58603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58604       };
58605     }
58606   }
58607
58608   jresult = (int)result;
58609   return jresult;
58610 }
58611
58612
58613 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_WAIT_TIME_get() {
58614   int jresult ;
58615   int result;
58616
58617   {
58618     try {
58619       result = (int)Dali::Toolkit::Tooltip::Property::WAIT_TIME;
58620     } catch (std::out_of_range& e) {
58621       {
58622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58623       };
58624     } catch (std::exception& e) {
58625       {
58626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58627       };
58628     } catch (Dali::DaliException e) {
58629       {
58630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58631       };
58632     } catch (...) {
58633       {
58634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58635       };
58636     }
58637   }
58638
58639   jresult = (int)result;
58640   return jresult;
58641 }
58642
58643
58644 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_get() {
58645   int jresult ;
58646   int result;
58647
58648   {
58649     try {
58650       result = (int)Dali::Toolkit::Tooltip::Property::BACKGROUND;
58651     } catch (std::out_of_range& e) {
58652       {
58653         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58654       };
58655     } catch (std::exception& e) {
58656       {
58657         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58658       };
58659     } catch (Dali::DaliException e) {
58660       {
58661         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58662       };
58663     } catch (...) {
58664       {
58665         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58666       };
58667     }
58668   }
58669
58670   jresult = (int)result;
58671   return jresult;
58672 }
58673
58674
58675 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_get() {
58676   int jresult ;
58677   int result;
58678
58679   {
58680     try {
58681       result = (int)Dali::Toolkit::Tooltip::Property::TAIL;
58682     } catch (std::out_of_range& e) {
58683       {
58684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58685       };
58686     } catch (std::exception& e) {
58687       {
58688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58689       };
58690     } catch (Dali::DaliException e) {
58691       {
58692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58693       };
58694     } catch (...) {
58695       {
58696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58697       };
58698     }
58699   }
58700
58701   jresult = (int)result;
58702   return jresult;
58703 }
58704
58705
58706 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_POSITION_get() {
58707   int jresult ;
58708   int result;
58709
58710   {
58711     try {
58712       result = (int)Dali::Toolkit::Tooltip::Property::POSITION;
58713     } catch (std::out_of_range& e) {
58714       {
58715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58716       };
58717     } catch (std::exception& e) {
58718       {
58719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58720       };
58721     } catch (Dali::DaliException e) {
58722       {
58723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58724       };
58725     } catch (...) {
58726       {
58727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58728       };
58729     }
58730   }
58731
58732   jresult = (int)result;
58733   return jresult;
58734 }
58735
58736
58737 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_HOVER_POINT_OFFSET_get() {
58738   int jresult ;
58739   int result;
58740
58741   {
58742     try {
58743       result = (int)Dali::Toolkit::Tooltip::Property::HOVER_POINT_OFFSET;
58744     } catch (std::out_of_range& e) {
58745       {
58746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58747       };
58748     } catch (std::exception& e) {
58749       {
58750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58751       };
58752     } catch (Dali::DaliException e) {
58753       {
58754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58755       };
58756     } catch (...) {
58757       {
58758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58759       };
58760     }
58761   }
58762
58763   jresult = (int)result;
58764   return jresult;
58765 }
58766
58767
58768 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_MOVEMENT_THRESHOLD_get() {
58769   int jresult ;
58770   int result;
58771
58772   {
58773     try {
58774       result = (int)Dali::Toolkit::Tooltip::Property::MOVEMENT_THRESHOLD;
58775     } catch (std::out_of_range& e) {
58776       {
58777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58778       };
58779     } catch (std::exception& e) {
58780       {
58781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58782       };
58783     } catch (Dali::DaliException e) {
58784       {
58785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58786       };
58787     } catch (...) {
58788       {
58789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58790       };
58791     }
58792   }
58793
58794   jresult = (int)result;
58795   return jresult;
58796 }
58797
58798
58799 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_DISAPPEAR_ON_MOVEMENT_get() {
58800   int jresult ;
58801   int result;
58802
58803   {
58804     try {
58805       result = (int)Dali::Toolkit::Tooltip::Property::DISAPPEAR_ON_MOVEMENT;
58806     } catch (std::out_of_range& e) {
58807       {
58808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58809       };
58810     } catch (std::exception& e) {
58811       {
58812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58813       };
58814     } catch (Dali::DaliException e) {
58815       {
58816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58817       };
58818     } catch (...) {
58819       {
58820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58821       };
58822     }
58823   }
58824
58825   jresult = (int)result;
58826   return jresult;
58827 }
58828
58829
58830 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_VISUAL_get() {
58831   int jresult ;
58832   int result;
58833
58834   {
58835     try {
58836       result = (int)Dali::Toolkit::Tooltip::Background::Property::VISUAL;
58837     } catch (std::out_of_range& e) {
58838       {
58839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58840       };
58841     } catch (std::exception& e) {
58842       {
58843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58844       };
58845     } catch (Dali::DaliException e) {
58846       {
58847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58848       };
58849     } catch (...) {
58850       {
58851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58852       };
58853     }
58854   }
58855
58856   jresult = (int)result;
58857   return jresult;
58858 }
58859
58860
58861 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_BACKGROUND_BORDER_get() {
58862   int jresult ;
58863   int result;
58864
58865   {
58866     try {
58867       result = (int)Dali::Toolkit::Tooltip::Background::Property::BORDER;
58868     } catch (std::out_of_range& e) {
58869       {
58870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58871       };
58872     } catch (std::exception& e) {
58873       {
58874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58875       };
58876     } catch (Dali::DaliException e) {
58877       {
58878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58879       };
58880     } catch (...) {
58881       {
58882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58883       };
58884     }
58885   }
58886
58887   jresult = (int)result;
58888   return jresult;
58889 }
58890
58891
58892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_VISIBILITY_get() {
58893   int jresult ;
58894   int result;
58895
58896   {
58897     try {
58898       result = (int)Dali::Toolkit::Tooltip::Tail::Property::VISIBILITY;
58899     } catch (std::out_of_range& e) {
58900       {
58901         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58902       };
58903     } catch (std::exception& e) {
58904       {
58905         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58906       };
58907     } catch (Dali::DaliException e) {
58908       {
58909         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58910       };
58911     } catch (...) {
58912       {
58913         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58914       };
58915     }
58916   }
58917
58918   jresult = (int)result;
58919   return jresult;
58920 }
58921
58922
58923 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_ABOVE_VISUAL_get() {
58924   int jresult ;
58925   int result;
58926
58927   {
58928     try {
58929       result = (int)Dali::Toolkit::Tooltip::Tail::Property::ABOVE_VISUAL;
58930     } catch (std::out_of_range& e) {
58931       {
58932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58933       };
58934     } catch (std::exception& e) {
58935       {
58936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58937       };
58938     } catch (Dali::DaliException e) {
58939       {
58940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58941       };
58942     } catch (...) {
58943       {
58944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58945       };
58946     }
58947   }
58948
58949   jresult = (int)result;
58950   return jresult;
58951 }
58952
58953
58954 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TOOLTIP_TAIL_BELOW_VISUAL_get() {
58955   int jresult ;
58956   int result;
58957
58958   {
58959     try {
58960       result = (int)Dali::Toolkit::Tooltip::Tail::Property::BELOW_VISUAL;
58961     } catch (std::out_of_range& e) {
58962       {
58963         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58964       };
58965     } catch (std::exception& e) {
58966       {
58967         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58968       };
58969     } catch (Dali::DaliException e) {
58970       {
58971         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
58972       };
58973     } catch (...) {
58974       {
58975         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
58976       };
58977     }
58978   }
58979
58980   jresult = (int)result;
58981   return jresult;
58982 }
58983
58984
58985 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_New() {
58986   void * jresult ;
58987   Dali::Toolkit::Control result;
58988
58989   {
58990     try {
58991       result = Dali::Toolkit::Internal::Control::New();
58992     } catch (std::out_of_range& e) {
58993       {
58994         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
58995       };
58996     } catch (std::exception& e) {
58997       {
58998         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
58999       };
59000     } catch (Dali::DaliException e) {
59001       {
59002         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59003       };
59004     } catch (...) {
59005       {
59006         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59007       };
59008     }
59009   }
59010
59011   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
59012   return jresult;
59013 }
59014
59015
59016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetStyleName(void * jarg1, char * jarg2) {
59017   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59018   std::string *arg2 = 0 ;
59019
59020   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59021   if (!jarg2) {
59022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
59023     return ;
59024   }
59025   std::string arg2_str(jarg2);
59026   arg2 = &arg2_str;
59027   {
59028     try {
59029       (arg1)->SetStyleName((std::string const &)*arg2);
59030     } catch (std::out_of_range& e) {
59031       {
59032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59033       };
59034     } catch (std::exception& e) {
59035       {
59036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59037       };
59038     } catch (Dali::DaliException e) {
59039       {
59040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59041       };
59042     } catch (...) {
59043       {
59044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59045       };
59046     }
59047   }
59048
59049
59050   //argout typemap for const std::string&
59051
59052 }
59053
59054
59055 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_ViewImpl_GetStyleName(void * jarg1) {
59056   char * jresult ;
59057   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59058   std::string *result = 0 ;
59059
59060   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59061   {
59062     try {
59063       result = (std::string *) &((Dali::Toolkit::Internal::Control const *)arg1)->GetStyleName();
59064     } catch (std::out_of_range& e) {
59065       {
59066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59067       };
59068     } catch (std::exception& e) {
59069       {
59070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59071       };
59072     } catch (Dali::DaliException e) {
59073       {
59074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59075       };
59076     } catch (...) {
59077       {
59078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59079       };
59080     }
59081   }
59082
59083   jresult = SWIG_csharp_string_callback(result->c_str());
59084   return jresult;
59085 }
59086
59087
59088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackgroundColor(void * jarg1, void * jarg2) {
59089   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59090   Dali::Vector4 *arg2 = 0 ;
59091
59092   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59093   arg2 = (Dali::Vector4 *)jarg2;
59094   if (!arg2) {
59095     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
59096     return ;
59097   }
59098   {
59099     try {
59100       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
59101     } catch (std::out_of_range& e) {
59102       {
59103         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59104       };
59105     } catch (std::exception& e) {
59106       {
59107         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59108       };
59109     } catch (Dali::DaliException e) {
59110       {
59111         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59112       };
59113     } catch (...) {
59114       {
59115         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59116       };
59117     }
59118   }
59119
59120 }
59121
59122
59123 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetBackgroundColor(void * jarg1) {
59124   void * jresult ;
59125   Dali::Handle *arg1 = (Dali::Handle *) 0 ;
59126   Dali::Vector4 result;
59127
59128   arg1 = (Dali::Handle *)jarg1;
59129   {
59130     try {
59131       Property::Map* resultMap = ((arg1)->GetProperty( Control::Property::BACKGROUND )).GetMap();
59132       if (resultMap)
59133       {
59134         Dali::Property::Value* type = resultMap->Find( Toolkit::Visual::Property::TYPE );
59135         if(type && type->Get<int>() == Visual::COLOR )
59136         {
59137           Dali::Property::Value* value = resultMap->Find( ColorVisual::Property::MIX_COLOR );
59138           if (value)
59139           {
59140             result = value->Get<Vector4>();
59141           }
59142         }
59143       }
59144     } catch (std::out_of_range& e) {
59145       {
59146         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59147       };
59148     } catch (std::exception& e) {
59149       {
59150         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59151       };
59152     } catch (Dali::DaliException e) {
59153       {
59154         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59155       };
59156     } catch (...) {
59157       {
59158         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59159       };
59160     }
59161   }
59162
59163   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
59164   return jresult;
59165 }
59166
59167
59168 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetBackground(void * jarg1, void * jarg2) {
59169   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59170   Dali::Property::Map *arg2 = 0 ;
59171
59172   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59173   arg2 = (Dali::Property::Map *)jarg2;
59174   if (!arg2) {
59175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
59176     return ;
59177   }
59178   {
59179     try {
59180       (arg1)->SetBackground((Dali::Property::Map const &)*arg2);
59181     } catch (std::out_of_range& e) {
59182       {
59183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59184       };
59185     } catch (std::exception& e) {
59186       {
59187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59188       };
59189     } catch (Dali::DaliException e) {
59190       {
59191         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59192       };
59193     } catch (...) {
59194       {
59195         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59196       };
59197     }
59198   }
59199
59200 }
59201
59202
59203 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearBackground(void * jarg1) {
59204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59205
59206   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59207   {
59208     try {
59209       (arg1)->ClearBackground();
59210     } catch (std::out_of_range& e) {
59211       {
59212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59213       };
59214     } catch (std::exception& e) {
59215       {
59216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59217       };
59218     } catch (Dali::DaliException e) {
59219       {
59220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59221       };
59222     } catch (...) {
59223       {
59224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59225       };
59226     }
59227   }
59228
59229 }
59230
59231
59232 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_EnableGestureDetection(void * jarg1, int jarg2) {
59233   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59234   Dali::Gesture::Type arg2 ;
59235
59236   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59237   arg2 = (Dali::Gesture::Type)jarg2;
59238   {
59239     try {
59240       (arg1)->EnableGestureDetection(arg2);
59241     } catch (std::out_of_range& e) {
59242       {
59243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59244       };
59245     } catch (std::exception& e) {
59246       {
59247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59248       };
59249     } catch (Dali::DaliException e) {
59250       {
59251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59252       };
59253     } catch (...) {
59254       {
59255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59256       };
59257     }
59258   }
59259
59260 }
59261
59262
59263 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_DisableGestureDetection(void * jarg1, int jarg2) {
59264   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59265   Dali::Gesture::Type arg2 ;
59266
59267   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59268   arg2 = (Dali::Gesture::Type)jarg2;
59269   {
59270     try {
59271       (arg1)->DisableGestureDetection(arg2);
59272     } catch (std::out_of_range& e) {
59273       {
59274         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59275       };
59276     } catch (std::exception& e) {
59277       {
59278         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59279       };
59280     } catch (Dali::DaliException e) {
59281       {
59282         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59283       };
59284     } catch (...) {
59285       {
59286         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59287       };
59288     }
59289   }
59290
59291 }
59292
59293
59294 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPinchGestureDetector(void * jarg1) {
59295   void * jresult ;
59296   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59297   Dali::PinchGestureDetector result;
59298
59299   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59300   {
59301     try {
59302       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPinchGestureDetector();
59303     } catch (std::out_of_range& e) {
59304       {
59305         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59306       };
59307     } catch (std::exception& e) {
59308       {
59309         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59310       };
59311     } catch (Dali::DaliException e) {
59312       {
59313         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59314       };
59315     } catch (...) {
59316       {
59317         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59318       };
59319     }
59320   }
59321
59322   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
59323   return jresult;
59324 }
59325
59326
59327 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetPanGestureDetector(void * jarg1) {
59328   void * jresult ;
59329   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59330   Dali::PanGestureDetector result;
59331
59332   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59333   {
59334     try {
59335       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetPanGestureDetector();
59336     } catch (std::out_of_range& e) {
59337       {
59338         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59339       };
59340     } catch (std::exception& e) {
59341       {
59342         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59343       };
59344     } catch (Dali::DaliException e) {
59345       {
59346         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59347       };
59348     } catch (...) {
59349       {
59350         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59351       };
59352     }
59353   }
59354
59355   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
59356   return jresult;
59357 }
59358
59359
59360 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetTapGestureDetector(void * jarg1) {
59361   void * jresult ;
59362   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59363   Dali::TapGestureDetector result;
59364
59365   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59366   {
59367     try {
59368       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetTapGestureDetector();
59369     } catch (std::out_of_range& e) {
59370       {
59371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59372       };
59373     } catch (std::exception& e) {
59374       {
59375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59376       };
59377     } catch (Dali::DaliException e) {
59378       {
59379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59380       };
59381     } catch (...) {
59382       {
59383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59384       };
59385     }
59386   }
59387
59388   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
59389   return jresult;
59390 }
59391
59392
59393 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetLongPressGestureDetector(void * jarg1) {
59394   void * jresult ;
59395   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59396   Dali::LongPressGestureDetector result;
59397
59398   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59399   {
59400     try {
59401       result = ((Dali::Toolkit::Internal::Control const *)arg1)->GetLongPressGestureDetector();
59402     } catch (std::out_of_range& e) {
59403       {
59404         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59405       };
59406     } catch (std::exception& e) {
59407       {
59408         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59409       };
59410     } catch (Dali::DaliException e) {
59411       {
59412         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59413       };
59414     } catch (...) {
59415       {
59416         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59417       };
59418     }
59419   }
59420
59421   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
59422   return jresult;
59423 }
59424
59425
59426 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyboardNavigationSupport(void * jarg1, unsigned int jarg2) {
59427   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59428   bool arg2 ;
59429
59430   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59431   arg2 = jarg2 ? true : false;
59432   {
59433     try {
59434       (arg1)->SetKeyboardNavigationSupport(arg2);
59435     } catch (std::out_of_range& e) {
59436       {
59437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59438       };
59439     } catch (std::exception& e) {
59440       {
59441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59442       };
59443     } catch (Dali::DaliException e) {
59444       {
59445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59446       };
59447     } catch (...) {
59448       {
59449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59450       };
59451     }
59452   }
59453
59454 }
59455
59456
59457 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardNavigationSupported(void * jarg1) {
59458   unsigned int jresult ;
59459   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59460   bool result;
59461
59462   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59463   {
59464     try {
59465       result = (bool)(arg1)->IsKeyboardNavigationSupported();
59466     } catch (std::out_of_range& e) {
59467       {
59468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59469       };
59470     } catch (std::exception& e) {
59471       {
59472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59473       };
59474     } catch (Dali::DaliException e) {
59475       {
59476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59477       };
59478     } catch (...) {
59479       {
59480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59481       };
59482     }
59483   }
59484
59485   jresult = result;
59486   return jresult;
59487 }
59488
59489
59490 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetKeyInputFocus(void * jarg1) {
59491   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59492
59493   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59494   {
59495     try {
59496       (arg1)->SetKeyInputFocus();
59497     } catch (std::out_of_range& e) {
59498       {
59499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59500       };
59501     } catch (std::exception& e) {
59502       {
59503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59504       };
59505     } catch (Dali::DaliException e) {
59506       {
59507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59508       };
59509     } catch (...) {
59510       {
59511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59512       };
59513     }
59514   }
59515
59516 }
59517
59518
59519 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_HasKeyInputFocus(void * jarg1) {
59520   unsigned int jresult ;
59521   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59522   bool result;
59523
59524   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59525   {
59526     try {
59527       result = (bool)(arg1)->HasKeyInputFocus();
59528     } catch (std::out_of_range& e) {
59529       {
59530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59531       };
59532     } catch (std::exception& e) {
59533       {
59534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59535       };
59536     } catch (Dali::DaliException e) {
59537       {
59538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59539       };
59540     } catch (...) {
59541       {
59542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59543       };
59544     }
59545   }
59546
59547   jresult = result;
59548   return jresult;
59549 }
59550
59551
59552 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_ClearKeyInputFocus(void * jarg1) {
59553   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59554
59555   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59556   {
59557     try {
59558       (arg1)->ClearKeyInputFocus();
59559     } catch (std::out_of_range& e) {
59560       {
59561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59562       };
59563     } catch (std::exception& e) {
59564       {
59565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59566       };
59567     } catch (Dali::DaliException e) {
59568       {
59569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59570       };
59571     } catch (...) {
59572       {
59573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59574       };
59575     }
59576   }
59577
59578 }
59579
59580
59581 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SetAsKeyboardFocusGroup(void * jarg1, unsigned int jarg2) {
59582   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59583   bool arg2 ;
59584
59585   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59586   arg2 = jarg2 ? true : false;
59587   {
59588     try {
59589       (arg1)->SetAsKeyboardFocusGroup(arg2);
59590     } catch (std::out_of_range& e) {
59591       {
59592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59593       };
59594     } catch (std::exception& e) {
59595       {
59596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59597       };
59598     } catch (Dali::DaliException e) {
59599       {
59600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59601       };
59602     } catch (...) {
59603       {
59604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59605       };
59606     }
59607   }
59608
59609 }
59610
59611
59612 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_IsKeyboardFocusGroup(void * jarg1) {
59613   unsigned int jresult ;
59614   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59615   bool result;
59616
59617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59618   {
59619     try {
59620       result = (bool)(arg1)->IsKeyboardFocusGroup();
59621     } catch (std::out_of_range& e) {
59622       {
59623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59624       };
59625     } catch (std::exception& e) {
59626       {
59627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59628       };
59629     } catch (Dali::DaliException e) {
59630       {
59631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59632       };
59633     } catch (...) {
59634       {
59635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59636       };
59637     }
59638   }
59639
59640   jresult = result;
59641   return jresult;
59642 }
59643
59644
59645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyEventSignal(void * jarg1) {
59646   void * jresult ;
59647   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59648   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
59649
59650   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59651   {
59652     try {
59653       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
59654     } catch (std::out_of_range& e) {
59655       {
59656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59657       };
59658     } catch (std::exception& e) {
59659       {
59660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59661       };
59662     } catch (Dali::DaliException e) {
59663       {
59664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59665       };
59666     } catch (...) {
59667       {
59668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59669       };
59670     }
59671   }
59672
59673   jresult = (void *)result;
59674   return jresult;
59675 }
59676
59677
59678 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusGainedSignal(void * jarg1) {
59679   void * jresult ;
59680   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59681   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59682
59683   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59684   {
59685     try {
59686       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
59687     } catch (std::out_of_range& e) {
59688       {
59689         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59690       };
59691     } catch (std::exception& e) {
59692       {
59693         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59694       };
59695     } catch (Dali::DaliException e) {
59696       {
59697         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59698       };
59699     } catch (...) {
59700       {
59701         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59702       };
59703     }
59704   }
59705
59706   jresult = (void *)result;
59707   return jresult;
59708 }
59709
59710
59711 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_KeyInputFocusLostSignal(void * jarg1) {
59712   void * jresult ;
59713   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59714   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
59715
59716   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59717   {
59718     try {
59719       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
59720     } catch (std::out_of_range& e) {
59721       {
59722         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
59723       };
59724     } catch (std::exception& e) {
59725       {
59726         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
59727       };
59728     } catch (Dali::DaliException e) {
59729       {
59730         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
59731       };
59732     } catch (...) {
59733       {
59734         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
59735       };
59736     }
59737   }
59738
59739   jresult = (void *)result;
59740   return jresult;
59741 }
59742
59743
59744 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnection(void * jarg1, int jarg2) {
59745   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59746   int arg2 ;
59747   SwigDirector_ViewImpl *darg = 0;
59748
59749   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59750   arg2 = (int)jarg2;
59751   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59752   if(!darg) {
59753     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59754     return;
59755   }
59756   {
59757     try {
59758       if(darg) {
59759         (darg)->OnStageConnection(arg2);
59760       }
59761     } catch (std::out_of_range& e) {
59762       {
59763         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59764       };
59765     } catch (std::exception& e) {
59766       {
59767         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59768       };
59769     } catch (Dali::DaliException e) {
59770       {
59771         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59772       };
59773     } catch (...) {
59774       {
59775         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59776       };
59777     }
59778   }
59779
59780 }
59781
59782
59783 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageConnectionSwigExplicitViewImpl(void * jarg1, int jarg2) {
59784   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59785   int arg2 ;
59786   SwigDirector_ViewImpl *darg = 0;
59787
59788   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59789   arg2 = (int)jarg2;
59790   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59791   if(!darg) {
59792     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59793     return;
59794   }
59795   {
59796     try {
59797       if(darg) {
59798         (darg)->OnStageConnectionSwigPublic(arg2);
59799       }
59800     } catch (std::out_of_range& e) {
59801       {
59802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59803       };
59804     } catch (std::exception& e) {
59805       {
59806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59807       };
59808     } catch (Dali::DaliException e) {
59809       {
59810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59811       };
59812     } catch (...) {
59813       {
59814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59815       };
59816     }
59817   }
59818
59819 }
59820
59821
59822 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnection(void * jarg1) {
59823   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59824   SwigDirector_ViewImpl *darg = 0;
59825
59826   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59827   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59828   if(!darg) {
59829     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59830     return;
59831   }
59832   {
59833     try {
59834       if(darg) {
59835         (darg)->OnStageDisconnection();
59836       }
59837     } catch (std::out_of_range& e) {
59838       {
59839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59840       };
59841     } catch (std::exception& e) {
59842       {
59843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59844       };
59845     } catch (Dali::DaliException e) {
59846       {
59847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59848       };
59849     } catch (...) {
59850       {
59851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59852       };
59853     }
59854   }
59855
59856 }
59857
59858
59859 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStageDisconnectionSwigExplicitViewImpl(void * jarg1) {
59860   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59861   SwigDirector_ViewImpl *darg = 0;
59862
59863   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59864   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59865   if(!darg) {
59866     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59867     return;
59868   }
59869   {
59870     try {
59871       if(darg) {
59872         (darg)->OnStageDisconnectionSwigPublic();
59873       }
59874     } catch (std::out_of_range& e) {
59875       {
59876         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59877       };
59878     } catch (std::exception& e) {
59879       {
59880         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59881       };
59882     } catch (Dali::DaliException e) {
59883       {
59884         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59885       };
59886     } catch (...) {
59887       {
59888         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59889       };
59890     }
59891   }
59892
59893 }
59894
59895
59896 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAdd(void * jarg1, void * jarg2) {
59897   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59898   Dali::Actor *arg2 = 0 ;
59899   SwigDirector_ViewImpl *darg = 0;
59900
59901   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59902   arg2 = (Dali::Actor *)jarg2;
59903   if (!arg2) {
59904     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59905     return ;
59906   }
59907   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59908   if(!darg) {
59909     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59910     return;
59911   }
59912   {
59913     try {
59914       if(darg) {
59915         (darg)->OnChildAdd(*arg2);
59916       }
59917     } catch (std::out_of_range& e) {
59918       {
59919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59920       };
59921     } catch (std::exception& e) {
59922       {
59923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59924       };
59925     } catch (Dali::DaliException e) {
59926       {
59927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59928       };
59929     } catch (...) {
59930       {
59931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59932       };
59933     }
59934   }
59935
59936 }
59937
59938
59939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildAddSwigExplicitViewImpl(void * jarg1, void * jarg2) {
59940   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59941   Dali::Actor *arg2 = 0 ;
59942   SwigDirector_ViewImpl *darg = 0;
59943
59944   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59945   arg2 = (Dali::Actor *)jarg2;
59946   if (!arg2) {
59947     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59948     return ;
59949   }
59950   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59951   if(!darg) {
59952     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59953     return;
59954   }
59955   {
59956     try {
59957       if(darg) {
59958           (darg)->OnChildAddSwigPublic(*arg2);
59959       }
59960     } catch (std::out_of_range& e) {
59961       {
59962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
59963       };
59964     } catch (std::exception& e) {
59965       {
59966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
59967       };
59968     } catch (Dali::DaliException e) {
59969       {
59970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
59971       };
59972     } catch (...) {
59973       {
59974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
59975       };
59976     }
59977   }
59978
59979 }
59980
59981
59982 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemove(void * jarg1, void * jarg2) {
59983   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
59984   Dali::Actor *arg2 = 0 ;
59985   SwigDirector_ViewImpl *darg = 0;
59986
59987   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
59988   arg2 = (Dali::Actor *)jarg2;
59989   if (!arg2) {
59990     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
59991     return ;
59992   }
59993   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
59994   if(!darg) {
59995     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
59996     return;
59997   }
59998   {
59999     try {
60000       if(darg) {
60001         (darg)->OnChildRemove(*arg2);
60002       }
60003     } catch (std::out_of_range& e) {
60004       {
60005         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60006       };
60007     } catch (std::exception& e) {
60008       {
60009         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60010       };
60011     } catch (Dali::DaliException e) {
60012       {
60013         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60014       };
60015     } catch (...) {
60016       {
60017         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60018       };
60019     }
60020   }
60021
60022 }
60023
60024
60025 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnChildRemoveSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60026   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60027   Dali::Actor *arg2 = 0 ;
60028   SwigDirector_ViewImpl *darg = 0;
60029
60030   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60031   arg2 = (Dali::Actor *)jarg2;
60032   if (!arg2) {
60033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
60034     return ;
60035   }
60036   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60037   if(!darg) {
60038     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60039     return;
60040   }
60041   {
60042     try {
60043       if(darg) {
60044         (darg)->OnChildRemoveSwigPublic(*arg2);
60045       }
60046     } catch (std::out_of_range& e) {
60047       {
60048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60049       };
60050     } catch (std::exception& e) {
60051       {
60052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60053       };
60054     } catch (Dali::DaliException e) {
60055       {
60056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60057       };
60058     } catch (...) {
60059       {
60060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60061       };
60062     }
60063   }
60064
60065 }
60066
60067
60068 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySet(void * jarg1, int jarg2, void * jarg3) {
60069   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60070   Dali::Property::Index arg2 ;
60071   Dali::Property::Value arg3 ;
60072   Dali::Property::Value *argp3 ;
60073   SwigDirector_ViewImpl *darg = 0;
60074
60075   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60076   arg2 = (Dali::Property::Index)jarg2;
60077   argp3 = (Dali::Property::Value *)jarg3;
60078   if (!argp3) {
60079     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60080     return ;
60081   }
60082   arg3 = *argp3;
60083   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60084   if (!darg) {
60085     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60086     return;
60087   }
60088   {
60089     try {
60090       (darg)->OnPropertySet(arg2,arg3);
60091     } catch (std::out_of_range& e) {
60092       {
60093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60094       };
60095     } catch (std::exception& e) {
60096       {
60097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60098       };
60099     } catch (Dali::DaliException e) {
60100       {
60101         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60102       };
60103     } catch (...) {
60104       {
60105         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60106       };
60107     }
60108   }
60109
60110 }
60111
60112
60113 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPropertySetSwigExplicitViewImpl(void * jarg1, int jarg2, void * jarg3) {
60114   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60115   Dali::Property::Index arg2 ;
60116   Dali::Property::Value arg3 ;
60117   Dali::Property::Value *argp3 ;
60118   SwigDirector_ViewImpl *darg = 0;
60119
60120   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60121   arg2 = (Dali::Property::Index)jarg2;
60122   argp3 = (Dali::Property::Value *)jarg3;
60123   if (!argp3) {
60124     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Property::Value", 0);
60125     return ;
60126   }
60127   arg3 = *argp3;
60128   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60129   if (!darg) {
60130     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60131     return;
60132   }
60133   {
60134     try {
60135       (darg)->OnPropertySetSwigPublic(arg2,arg3);
60136     } catch (std::out_of_range& e) {
60137       {
60138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60139       };
60140     } catch (std::exception& e) {
60141       {
60142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60143       };
60144     } catch (Dali::DaliException e) {
60145       {
60146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60147       };
60148     } catch (...) {
60149       {
60150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60151       };
60152     }
60153   }
60154
60155 }
60156
60157
60158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSet(void * jarg1, void * jarg2) {
60159   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60160   Dali::Vector3 *arg2 = 0 ;
60161   SwigDirector_ViewImpl *darg = 0;
60162
60163   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60164   arg2 = (Dali::Vector3 *)jarg2;
60165   if (!arg2) {
60166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60167     return ;
60168   }
60169   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60170   if (!darg) {
60171     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60172     return;
60173   }
60174   {
60175     try {
60176       (darg)->OnSizeSet((Dali::Vector3 const &)*arg2);
60177     } catch (std::out_of_range& e) {
60178       {
60179         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60180       };
60181     } catch (std::exception& e) {
60182       {
60183         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60184       };
60185     } catch (Dali::DaliException e) {
60186       {
60187         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60188       };
60189     } catch (...) {
60190       {
60191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60192       };
60193     }
60194   }
60195
60196 }
60197
60198
60199 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeSetSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60200   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60201   Dali::Vector3 *arg2 = 0 ;
60202   SwigDirector_ViewImpl *darg = 0;
60203
60204   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60205   arg2 = (Dali::Vector3 *)jarg2;
60206   if (!arg2) {
60207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60208     return ;
60209   }
60210   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60211   if (!darg) {
60212     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60213     return;
60214   }
60215   {
60216     try {
60217       (darg)->OnSizeSetSwigPublic((Dali::Vector3 const &)*arg2);
60218     } catch (std::out_of_range& e) {
60219       {
60220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60221       };
60222     } catch (std::exception& e) {
60223       {
60224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60225       };
60226     } catch (Dali::DaliException e) {
60227       {
60228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60229       };
60230     } catch (...) {
60231       {
60232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60233       };
60234     }
60235   }
60236
60237 }
60238
60239
60240 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimation(void * jarg1, void * jarg2, void * jarg3) {
60241   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60242   Dali::Animation *arg2 = 0 ;
60243   Dali::Vector3 *arg3 = 0 ;
60244   SwigDirector_ViewImpl *darg = 0;
60245
60246   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60247   arg2 = (Dali::Animation *)jarg2;
60248   if (!arg2) {
60249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60250     return ;
60251   }
60252   arg3 = (Dali::Vector3 *)jarg3;
60253   if (!arg3) {
60254     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60255     return ;
60256   }
60257   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60258   if (!darg) {
60259     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60260     return;
60261   }
60262   {
60263     try {
60264       (darg)->OnSizeAnimation(*arg2,(Dali::Vector3 const &)*arg3);
60265     } catch (std::out_of_range& e) {
60266       {
60267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60268       };
60269     } catch (std::exception& e) {
60270       {
60271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60272       };
60273     } catch (Dali::DaliException e) {
60274       {
60275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60276       };
60277     } catch (...) {
60278       {
60279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60280       };
60281     }
60282   }
60283
60284 }
60285
60286
60287 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSizeAnimationSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60288   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60289   Dali::Animation *arg2 = 0 ;
60290   Dali::Vector3 *arg3 = 0 ;
60291   SwigDirector_ViewImpl *darg = 0;
60292
60293   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60294   arg2 = (Dali::Animation *)jarg2;
60295   if (!arg2) {
60296     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Animation & type is null", 0);
60297     return ;
60298   }
60299   arg3 = (Dali::Vector3 *)jarg3;
60300   if (!arg3) {
60301     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
60302     return ;
60303   }
60304   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60305   if (!darg) {
60306     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60307     return;
60308   }
60309   {
60310     try {
60311       (darg)->OnSizeAnimationSwigPublic(*arg2,(Dali::Vector3 const &)*arg3);
60312     } catch (std::out_of_range& e) {
60313       {
60314         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60315       };
60316     } catch (std::exception& e) {
60317       {
60318         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60319       };
60320     } catch (Dali::DaliException e) {
60321       {
60322         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60323       };
60324     } catch (...) {
60325       {
60326         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60327       };
60328     }
60329   }
60330
60331 }
60332
60333
60334 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEvent(void * jarg1, void * jarg2) {
60335   unsigned int jresult ;
60336   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60337   Dali::TouchEvent *arg2 = 0 ;
60338   SwigDirector_ViewImpl *darg = 0;
60339   bool result;
60340
60341   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60342   arg2 = (Dali::TouchEvent *)jarg2;
60343   if (!arg2) {
60344     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60345     return 0;
60346   }
60347   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60348   if (!darg) {
60349     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60350     return 0;
60351   }
60352   {
60353     try {
60354       result = (bool)(darg)->OnTouchEvent((Dali::TouchEvent const &)*arg2);
60355     } catch (std::out_of_range& e) {
60356       {
60357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60358       };
60359     } catch (std::exception& e) {
60360       {
60361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60362       };
60363     } catch (Dali::DaliException e) {
60364       {
60365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60366       };
60367     } catch (...) {
60368       {
60369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60370       };
60371     }
60372   }
60373
60374   jresult = result;
60375   return jresult;
60376 }
60377
60378
60379 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnTouchEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60380   unsigned int jresult ;
60381   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60382   Dali::TouchEvent *arg2 = 0 ;
60383   SwigDirector_ViewImpl *darg = 0;
60384   bool result;
60385
60386   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60387   arg2 = (Dali::TouchEvent *)jarg2;
60388   if (!arg2) {
60389     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
60390     return 0;
60391   }
60392   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60393   if (!darg) {
60394     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60395     return 0;
60396   }
60397   {
60398     try {
60399       result = (bool)(darg)->OnTouchEventSwigPublic((Dali::TouchEvent const &)*arg2);
60400     } catch (std::out_of_range& e) {
60401       {
60402         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60403       };
60404     } catch (std::exception& e) {
60405       {
60406         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60407       };
60408     } catch (Dali::DaliException e) {
60409       {
60410         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60411       };
60412     } catch (...) {
60413       {
60414         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60415       };
60416     }
60417   }
60418
60419   jresult = result;
60420   return jresult;
60421 }
60422
60423
60424 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEvent(void * jarg1, void * jarg2) {
60425   unsigned int jresult ;
60426   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60427   Dali::HoverEvent *arg2 = 0 ;
60428   SwigDirector_ViewImpl *darg = 0;
60429   bool result;
60430
60431   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60432   arg2 = (Dali::HoverEvent *)jarg2;
60433   if (!arg2) {
60434     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60435     return 0;
60436   }
60437   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60438   if (!darg) {
60439     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60440     return 0;
60441   }
60442   {
60443     try {
60444       result = (bool)(darg)->OnHoverEvent((Dali::HoverEvent const &)*arg2);
60445     } catch (std::out_of_range& e) {
60446       {
60447         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60448       };
60449     } catch (std::exception& e) {
60450       {
60451         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60452       };
60453     } catch (Dali::DaliException e) {
60454       {
60455         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60456       };
60457     } catch (...) {
60458       {
60459         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60460       };
60461     }
60462   }
60463
60464   jresult = result;
60465   return jresult;
60466 }
60467
60468
60469 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnHoverEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60470   unsigned int jresult ;
60471   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60472   Dali::HoverEvent *arg2 = 0 ;
60473   SwigDirector_ViewImpl *darg = 0;
60474   bool result;
60475
60476   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60477   arg2 = (Dali::HoverEvent *)jarg2;
60478   if (!arg2) {
60479     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::HoverEvent const & type is null", 0);
60480     return 0;
60481   }
60482   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60483   if (!darg) {
60484     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60485     return 0;
60486   }
60487   {
60488     try {
60489       result = (bool)(darg)->OnHoverEventSwigPublic((Dali::HoverEvent const &)*arg2);
60490     } catch (std::out_of_range& e) {
60491       {
60492         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60493       };
60494     } catch (std::exception& e) {
60495       {
60496         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60497       };
60498     } catch (Dali::DaliException e) {
60499       {
60500         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60501       };
60502     } catch (...) {
60503       {
60504         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60505       };
60506     }
60507   }
60508
60509   jresult = result;
60510   return jresult;
60511 }
60512
60513
60514 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEvent(void * jarg1, void * jarg2) {
60515   unsigned int jresult ;
60516   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60517   Dali::KeyEvent *arg2 = 0 ;
60518   SwigDirector_ViewImpl *darg = 0;
60519   bool result;
60520
60521   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60522   arg2 = (Dali::KeyEvent *)jarg2;
60523   if (!arg2) {
60524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60525     return 0;
60526   }
60527   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60528   if (!darg) {
60529     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60530     return 0;
60531   }
60532   {
60533     try {
60534       result = (bool)(darg)->OnKeyEvent((Dali::KeyEvent const &)*arg2);
60535     } catch (std::out_of_range& e) {
60536       {
60537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60538       };
60539     } catch (std::exception& e) {
60540       {
60541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60542       };
60543     } catch (Dali::DaliException e) {
60544       {
60545         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60546       };
60547     } catch (...) {
60548       {
60549         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60550       };
60551     }
60552   }
60553
60554   jresult = result;
60555   return jresult;
60556 }
60557
60558
60559 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60560   unsigned int jresult ;
60561   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60562   Dali::KeyEvent *arg2 = 0 ;
60563   SwigDirector_ViewImpl *darg = 0;
60564   bool result;
60565
60566   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60567   arg2 = (Dali::KeyEvent *)jarg2;
60568   if (!arg2) {
60569     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
60570     return 0;
60571   }
60572   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60573   if (!darg) {
60574     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60575     return 0;
60576   }
60577   {
60578     try {
60579       result = (bool)(darg)->OnKeyEventSwigPublic((Dali::KeyEvent const &)*arg2);
60580     } catch (std::out_of_range& e) {
60581       {
60582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60583       };
60584     } catch (std::exception& e) {
60585       {
60586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60587       };
60588     } catch (Dali::DaliException e) {
60589       {
60590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60591       };
60592     } catch (...) {
60593       {
60594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60595       };
60596     }
60597   }
60598
60599   jresult = result;
60600   return jresult;
60601 }
60602
60603
60604 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEvent(void * jarg1, void * jarg2) {
60605   unsigned int jresult ;
60606   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60607   Dali::WheelEvent *arg2 = 0 ;
60608   SwigDirector_ViewImpl *darg = 0;
60609   bool result;
60610
60611   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60612   arg2 = (Dali::WheelEvent *)jarg2;
60613   if (!arg2) {
60614     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60615     return 0;
60616   }
60617   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60618   if (!darg) {
60619     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60620     return 0;
60621   }
60622   {
60623     try {
60624       result = (bool)(darg)->OnWheelEvent((Dali::WheelEvent const &)*arg2);
60625     } catch (std::out_of_range& e) {
60626       {
60627         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60628       };
60629     } catch (std::exception& e) {
60630       {
60631         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60632       };
60633     } catch (Dali::DaliException e) {
60634       {
60635         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60636       };
60637     } catch (...) {
60638       {
60639         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60640       };
60641     }
60642   }
60643
60644   jresult = result;
60645   return jresult;
60646 }
60647
60648
60649 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnWheelEventSwigExplicitViewImpl(void * jarg1, void * jarg2) {
60650   unsigned int jresult ;
60651   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60652   Dali::WheelEvent *arg2 = 0 ;
60653   SwigDirector_ViewImpl *darg = 0;
60654   bool result;
60655
60656   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60657   arg2 = (Dali::WheelEvent *)jarg2;
60658   if (!arg2) {
60659     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WheelEvent const & type is null", 0);
60660     return 0;
60661   }
60662   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60663   if (!darg) {
60664     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60665     return 0;
60666   }
60667   {
60668     try {
60669       result = (bool)(darg)->OnWheelEventSwigPublic((Dali::WheelEvent const &)*arg2);
60670     } catch (std::out_of_range& e) {
60671       {
60672         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60673       };
60674     } catch (std::exception& e) {
60675       {
60676         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60677       };
60678     } catch (Dali::DaliException e) {
60679       {
60680         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60681       };
60682     } catch (...) {
60683       {
60684         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60685       };
60686     }
60687   }
60688
60689   jresult = result;
60690   return jresult;
60691 }
60692
60693
60694 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayout(void * jarg1, void * jarg2, void * jarg3) {
60695   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60696   Dali::Vector2 *arg2 = 0 ;
60697   Dali::RelayoutContainer *arg3 = 0 ;
60698   SwigDirector_ViewImpl *darg = 0;
60699
60700   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60701   arg2 = (Dali::Vector2 *)jarg2;
60702   if (!arg2) {
60703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60704     return ;
60705   }
60706   arg3 = (Dali::RelayoutContainer *)jarg3;
60707   if (!arg3) {
60708     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60709     return ;
60710   }
60711   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60712   if (!darg) {
60713     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60714     return;
60715   }
60716   {
60717     try {
60718       (darg)->OnRelayout((Dali::Vector2 const &)*arg2,*arg3);
60719     } catch (std::out_of_range& e) {
60720       {
60721         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60722       };
60723     } catch (std::exception& e) {
60724       {
60725         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60726       };
60727     } catch (Dali::DaliException e) {
60728       {
60729         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60730       };
60731     } catch (...) {
60732       {
60733         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60734       };
60735     }
60736   }
60737
60738 }
60739
60740
60741 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnRelayoutSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
60742   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60743   Dali::Vector2 *arg2 = 0 ;
60744   Dali::RelayoutContainer *arg3 = 0 ;
60745   SwigDirector_ViewImpl *darg = 0;
60746
60747   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60748   arg2 = (Dali::Vector2 *)jarg2;
60749   if (!arg2) {
60750     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
60751     return ;
60752   }
60753   arg3 = (Dali::RelayoutContainer *)jarg3;
60754   if (!arg3) {
60755     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::RelayoutContainer & type is null", 0);
60756     return ;
60757   }
60758   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60759   if (!darg) {
60760     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60761     return;
60762   }
60763   {
60764     try {
60765       (darg)->OnRelayoutSwigPublic((Dali::Vector2 const &)*arg2,*arg3);
60766     } catch (std::out_of_range& e) {
60767       {
60768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60769       };
60770     } catch (std::exception& e) {
60771       {
60772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60773       };
60774     } catch (Dali::DaliException e) {
60775       {
60776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60777       };
60778     } catch (...) {
60779       {
60780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60781       };
60782     }
60783   }
60784
60785 }
60786
60787
60788 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicy(void * jarg1, int jarg2, int jarg3) {
60789   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60790   Dali::ResizePolicy::Type arg2 ;
60791   Dali::Dimension::Type arg3 ;
60792   SwigDirector_ViewImpl *darg = 0;
60793
60794   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60795   arg2 = (Dali::ResizePolicy::Type)jarg2;
60796   arg3 = (Dali::Dimension::Type)jarg3;
60797   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60798   if (!darg) {
60799     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60800     return;
60801   }
60802   {
60803     try {
60804       (darg)->OnSetResizePolicy(arg2,arg3);
60805     } catch (std::out_of_range& e) {
60806       {
60807         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60808       };
60809     } catch (std::exception& e) {
60810       {
60811         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60812       };
60813     } catch (Dali::DaliException e) {
60814       {
60815         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60816       };
60817     } catch (...) {
60818       {
60819         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60820       };
60821     }
60822   }
60823
60824 }
60825
60826
60827 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnSetResizePolicySwigExplicitViewImpl(void * jarg1, int jarg2, int jarg3) {
60828   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60829   Dali::ResizePolicy::Type arg2 ;
60830   Dali::Dimension::Type arg3 ;
60831   SwigDirector_ViewImpl *darg = 0;
60832
60833   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60834   arg2 = (Dali::ResizePolicy::Type)jarg2;
60835   arg3 = (Dali::Dimension::Type)jarg3;
60836   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60837   if (!darg) {
60838     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60839     return;
60840   }
60841   {
60842     try {
60843       (darg)->OnSetResizePolicySwigPublic(arg2,arg3);
60844     } catch (std::out_of_range& e) {
60845       {
60846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
60847       };
60848     } catch (std::exception& e) {
60849       {
60850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
60851       };
60852     } catch (Dali::DaliException e) {
60853       {
60854         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
60855       };
60856     } catch (...) {
60857       {
60858         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
60859       };
60860     }
60861   }
60862
60863 }
60864
60865
60866 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSize(void * jarg1) {
60867   void * jresult ;
60868   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60869   SwigDirector_ViewImpl *darg = 0;
60870   Dali::Vector3 result;
60871
60872   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60873   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60874   if (!darg) {
60875     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60876     return 0;
60877   }
60878   {
60879     try {
60880       result = (darg)->GetNaturalSize();
60881     } catch (std::out_of_range& e) {
60882       {
60883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60884       };
60885     } catch (std::exception& e) {
60886       {
60887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60888       };
60889     } catch (Dali::DaliException e) {
60890       {
60891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60892       };
60893     } catch (...) {
60894       {
60895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60896       };
60897     }
60898   }
60899
60900   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60901   return jresult;
60902 }
60903
60904
60905 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNaturalSizeSwigExplicitViewImpl(void * jarg1) {
60906   void * jresult ;
60907   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60908   SwigDirector_ViewImpl *darg = 0;
60909   Dali::Vector3 result;
60910
60911   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60912   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60913   if (!darg) {
60914     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60915     return 0;
60916   }
60917   {
60918     try {
60919       result = (darg)->GetNaturalSizeSwigPublic();
60920     } catch (std::out_of_range& e) {
60921       {
60922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60923       };
60924     } catch (std::exception& e) {
60925       {
60926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60927       };
60928     } catch (Dali::DaliException e) {
60929       {
60930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60931       };
60932     } catch (...) {
60933       {
60934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60935       };
60936     }
60937   }
60938
60939   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
60940   return jresult;
60941 }
60942
60943
60944 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSize(void * jarg1, void * jarg2, int jarg3) {
60945   float jresult ;
60946   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60947   Dali::Actor *arg2 = 0 ;
60948   Dali::Dimension::Type arg3 ;
60949   SwigDirector_ViewImpl *darg = 0;
60950   float result;
60951
60952   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
60953   arg2 = (Dali::Actor *)jarg2;
60954   if (!arg2) {
60955     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
60956     return 0;
60957   }
60958   arg3 = (Dali::Dimension::Type)jarg3;
60959   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
60960   if (!darg) {
60961     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
60962     return 0;
60963   }
60964   {
60965     try {
60966       result = (float)(darg)->CalculateChildSize((Dali::Actor const &)*arg2,arg3);
60967     } catch (std::out_of_range& e) {
60968       {
60969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
60970       };
60971     } catch (std::exception& e) {
60972       {
60973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
60974       };
60975     } catch (Dali::DaliException e) {
60976       {
60977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
60978       };
60979     } catch (...) {
60980       {
60981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
60982       };
60983     }
60984   }
60985
60986   jresult = result;
60987   return jresult;
60988 }
60989
60990
60991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_CalculateChildSizeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
60992   float jresult ;
60993   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
60994   Dali::Actor *arg2 = 0 ;
60995   Dali::Dimension::Type arg3 ;
60996   SwigDirector_ViewImpl *darg = 0;
60997   float result;
60998
60999   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61000   arg2 = (Dali::Actor *)jarg2;
61001   if (!arg2) {
61002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
61003     return 0;
61004   }
61005   arg3 = (Dali::Dimension::Type)jarg3;
61006   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61007   if (!darg) {
61008     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61009     return 0;
61010   }
61011   {
61012     try {
61013       result = (float)(darg)->CalculateChildSizeSwigPublic((Dali::Actor const &)*arg2,arg3);
61014     } catch (std::out_of_range& e) {
61015       {
61016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61017       };
61018     } catch (std::exception& e) {
61019       {
61020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61021       };
61022     } catch (Dali::DaliException e) {
61023       {
61024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61025       };
61026     } catch (...) {
61027       {
61028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61029       };
61030     }
61031   }
61032
61033   jresult = result;
61034   return jresult;
61035 }
61036
61037
61038 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidth(void * jarg1, float jarg2) {
61039   float jresult ;
61040   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61041   float arg2 ;
61042   SwigDirector_ViewImpl *darg = 0;
61043   float result;
61044
61045   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61046   arg2 = (float)jarg2;
61047   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61048   if (!darg) {
61049     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61050     return 0;
61051   }
61052   {
61053     try {
61054       result = (float)(darg)->GetHeightForWidth(arg2);
61055     } catch (std::out_of_range& e) {
61056       {
61057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61058       };
61059     } catch (std::exception& e) {
61060       {
61061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61062       };
61063     } catch (Dali::DaliException e) {
61064       {
61065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61066       };
61067     } catch (...) {
61068       {
61069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61070       };
61071     }
61072   }
61073
61074   jresult = result;
61075   return jresult;
61076 }
61077
61078
61079 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetHeightForWidthSwigExplicitViewImpl(void * jarg1, float jarg2) {
61080   float jresult ;
61081   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61082   float arg2 ;
61083   SwigDirector_ViewImpl *darg = 0;
61084   float result;
61085
61086   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61087   arg2 = (float)jarg2;
61088   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61089   if (!darg) {
61090     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61091     return 0;
61092   }
61093   {
61094     try {
61095       result = (float)(darg)->GetHeightForWidthSwigPublic(arg2);
61096     } catch (std::out_of_range& e) {
61097       {
61098         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61099       };
61100     } catch (std::exception& e) {
61101       {
61102         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61103       };
61104     } catch (Dali::DaliException e) {
61105       {
61106         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61107       };
61108     } catch (...) {
61109       {
61110         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61111       };
61112     }
61113   }
61114
61115   jresult = result;
61116   return jresult;
61117 }
61118
61119
61120 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeight(void * jarg1, float jarg2) {
61121   float jresult ;
61122   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61123   float arg2 ;
61124   SwigDirector_ViewImpl *darg = 0;
61125   float result;
61126
61127   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61128   arg2 = (float)jarg2;
61129   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61130   if (!darg) {
61131     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61132     return 0;
61133   }
61134   {
61135     try {
61136       result = (float)(darg)->GetWidthForHeight(arg2);
61137     } catch (std::out_of_range& e) {
61138       {
61139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61140       };
61141     } catch (std::exception& e) {
61142       {
61143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61144       };
61145     } catch (Dali::DaliException e) {
61146       {
61147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61148       };
61149     } catch (...) {
61150       {
61151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61152       };
61153     }
61154   }
61155
61156   jresult = result;
61157   return jresult;
61158 }
61159
61160
61161 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ViewImpl_GetWidthForHeightSwigExplicitViewImpl(void * jarg1, float jarg2) {
61162   float jresult ;
61163   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61164   float arg2 ;
61165   SwigDirector_ViewImpl *darg = 0;
61166   float result;
61167
61168   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61169   arg2 = (float)jarg2;
61170   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61171   if (!darg) {
61172     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61173     return 0;
61174   }
61175   {
61176     try {
61177       result = (float)(darg)->GetWidthForHeightSwigPublic(arg2);
61178     } catch (std::out_of_range& e) {
61179       {
61180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61181       };
61182     } catch (std::exception& e) {
61183       {
61184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61185       };
61186     } catch (Dali::DaliException e) {
61187       {
61188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61189       };
61190     } catch (...) {
61191       {
61192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61193       };
61194     }
61195   }
61196
61197   jresult = result;
61198   return jresult;
61199 }
61200
61201
61202 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_0(void * jarg1, int jarg2) {
61203   unsigned int jresult ;
61204   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61205   Dali::Dimension::Type arg2 ;
61206   SwigDirector_ViewImpl *darg = 0;
61207   bool result;
61208
61209   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61210   arg2 = (Dali::Dimension::Type)jarg2;
61211   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61212   if (!darg) {
61213     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61214     return 0;
61215   }
61216   {
61217     try {
61218       result = (bool)(darg)->RelayoutDependentOnChildren(arg2);
61219     } catch (std::out_of_range& e) {
61220       {
61221         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61222       };
61223     } catch (std::exception& e) {
61224       {
61225         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61226       };
61227     } catch (Dali::DaliException e) {
61228       {
61229         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61230       };
61231     } catch (...) {
61232       {
61233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61234       };
61235     }
61236   }
61237
61238   jresult = result;
61239   return jresult;
61240 }
61241
61242
61243 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_0(void * jarg1, int jarg2) {
61244   unsigned int jresult ;
61245   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61246   Dali::Dimension::Type arg2 ;
61247   SwigDirector_ViewImpl *darg = 0;
61248   bool result;
61249
61250   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61251   arg2 = (Dali::Dimension::Type)jarg2;
61252   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61253   if (!darg) {
61254     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61255     return 0;
61256   }
61257   {
61258     try {
61259       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic(arg2);
61260     } catch (std::out_of_range& e) {
61261       {
61262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61263       };
61264     } catch (std::exception& e) {
61265       {
61266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61267       };
61268     } catch (Dali::DaliException e) {
61269       {
61270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61271       };
61272     } catch (...) {
61273       {
61274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61275       };
61276     }
61277   }
61278
61279   jresult = result;
61280   return jresult;
61281 }
61282
61283
61284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildren__SWIG_1(void * jarg1) {
61285   unsigned int jresult ;
61286   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61287   SwigDirector_ViewImpl *darg = 0;
61288   bool result;
61289
61290   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61291   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61292   if (!darg) {
61293     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61294     return 0;
61295   }
61296   {
61297     try {
61298       result = (bool)(darg)->RelayoutDependentOnChildren();
61299     } catch (std::out_of_range& e) {
61300       {
61301         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61302       };
61303     } catch (std::exception& e) {
61304       {
61305         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61306       };
61307     } catch (Dali::DaliException e) {
61308       {
61309         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61310       };
61311     } catch (...) {
61312       {
61313         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61314       };
61315     }
61316   }
61317
61318   jresult = result;
61319   return jresult;
61320 }
61321
61322
61323 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_RelayoutDependentOnChildrenSwigExplicitViewImpl__SWIG_1(void * jarg1) {
61324   unsigned int jresult ;
61325   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61326   SwigDirector_ViewImpl *darg = 0;
61327   bool result;
61328
61329   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61330   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61331   if (!darg) {
61332     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61333     return 0;
61334   }
61335   {
61336     try {
61337       result = (bool)(darg)->RelayoutDependentOnChildrenSwigPublic();
61338     } catch (std::out_of_range& e) {
61339       {
61340         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61341       };
61342     } catch (std::exception& e) {
61343       {
61344         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61345       };
61346     } catch (Dali::DaliException e) {
61347       {
61348         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61349       };
61350     } catch (...) {
61351       {
61352         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61353       };
61354     }
61355   }
61356
61357   jresult = result;
61358   return jresult;
61359 }
61360
61361
61362 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSize(void * jarg1, int jarg2) {
61363   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61364   Dali::Dimension::Type arg2 ;
61365   SwigDirector_ViewImpl *darg = 0;
61366
61367   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61368   arg2 = (Dali::Dimension::Type)jarg2;
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;
61373   }
61374   {
61375     try {
61376       (darg)->OnCalculateRelayoutSize(arg2);
61377     } catch (std::out_of_range& e) {
61378       {
61379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61380       };
61381     } catch (std::exception& e) {
61382       {
61383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61384       };
61385     } catch (Dali::DaliException e) {
61386       {
61387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61388       };
61389     } catch (...) {
61390       {
61391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61392       };
61393     }
61394   }
61395
61396 }
61397
61398
61399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnCalculateRelayoutSizeSwigExplicitViewImpl(void * jarg1, int jarg2) {
61400   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61401   Dali::Dimension::Type arg2 ;
61402   SwigDirector_ViewImpl *darg = 0;
61403
61404   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61405   arg2 = (Dali::Dimension::Type)jarg2;
61406   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61407   if (!darg) {
61408     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61409     return;
61410   }
61411   {
61412     try {
61413       (darg)->OnCalculateRelayoutSizeSwigPublic(arg2);
61414     } catch (std::out_of_range& e) {
61415       {
61416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61417       };
61418     } catch (std::exception& e) {
61419       {
61420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61421       };
61422     } catch (Dali::DaliException e) {
61423       {
61424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61425       };
61426     } catch (...) {
61427       {
61428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61429       };
61430     }
61431   }
61432
61433 }
61434
61435
61436 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiated(void * jarg1, float jarg2, int jarg3) {
61437   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61438   float arg2 ;
61439   Dali::Dimension::Type arg3 ;
61440   SwigDirector_ViewImpl *darg = 0;
61441
61442   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61443   arg2 = (float)jarg2;
61444   arg3 = (Dali::Dimension::Type)jarg3;
61445   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61446   if (!darg) {
61447     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61448     return;
61449   }
61450   {
61451     try {
61452       (darg)->OnLayoutNegotiated(arg2,arg3);
61453     } catch (std::out_of_range& e) {
61454       {
61455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61456       };
61457     } catch (std::exception& e) {
61458       {
61459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61460       };
61461     } catch (Dali::DaliException e) {
61462       {
61463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61464       };
61465     } catch (...) {
61466       {
61467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61468       };
61469     }
61470   }
61471
61472 }
61473
61474
61475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLayoutNegotiatedSwigExplicitViewImpl(void * jarg1, float jarg2, int jarg3) {
61476   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61477   float arg2 ;
61478   Dali::Dimension::Type arg3 ;
61479   SwigDirector_ViewImpl *darg = 0;
61480
61481   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61482   arg2 = (float)jarg2;
61483   arg3 = (Dali::Dimension::Type)jarg3;
61484   darg = dynamic_cast<SwigDirector_ViewImpl *>(arg1);
61485   if (!darg) {
61486     SWIG_CSharpException(SWIG_TypeError, "dynamic_cast<SwigDirector_ViewImpl> error. darg is null");
61487     return;
61488   }
61489   {
61490     try {
61491       (darg)->OnLayoutNegotiatedSwigPublic(arg2,arg3);
61492     } catch (std::out_of_range& e) {
61493       {
61494         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61495       };
61496     } catch (std::exception& e) {
61497       {
61498         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61499       };
61500     } catch (Dali::DaliException e) {
61501       {
61502         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61503       };
61504     } catch (...) {
61505       {
61506         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61507       };
61508     }
61509   }
61510
61511 }
61512
61513
61514 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitialize(void * jarg1) {
61515   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61516
61517   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61518   {
61519     try {
61520       (arg1)->OnInitialize();
61521     } catch (std::out_of_range& e) {
61522       {
61523         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61524       };
61525     } catch (std::exception& e) {
61526       {
61527         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61528       };
61529     } catch (Dali::DaliException e) {
61530       {
61531         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61532       };
61533     } catch (...) {
61534       {
61535         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61536       };
61537     }
61538   }
61539
61540 }
61541
61542
61543 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnInitializeSwigExplicitViewImpl(void * jarg1) {
61544   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61545
61546   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61547   {
61548     try {
61549       (arg1)->Dali::Toolkit::Internal::Control::OnInitialize();
61550     } catch (std::out_of_range& e) {
61551       {
61552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61553       };
61554     } catch (std::exception& e) {
61555       {
61556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61557       };
61558     } catch (Dali::DaliException e) {
61559       {
61560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61561       };
61562     } catch (...) {
61563       {
61564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61565       };
61566     }
61567   }
61568
61569 }
61570
61571
61572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChange(void * jarg1, void * jarg2, int jarg3) {
61573   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61574   Dali::Toolkit::StyleManager arg2 ;
61575   Dali::StyleChange::Type arg3 ;
61576   Dali::Toolkit::StyleManager *argp2 ;
61577
61578   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61579   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61580   if (!argp2) {
61581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61582     return ;
61583   }
61584   arg2 = *argp2;
61585   arg3 = (Dali::StyleChange::Type)jarg3;
61586   {
61587     try {
61588       (arg1)->OnStyleChange(arg2,arg3);
61589     } catch (std::out_of_range& e) {
61590       {
61591         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61592       };
61593     } catch (std::exception& e) {
61594       {
61595         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61596       };
61597     } catch (Dali::DaliException e) {
61598       {
61599         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61600       };
61601     } catch (...) {
61602       {
61603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61604       };
61605     }
61606   }
61607
61608 }
61609
61610
61611 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnStyleChangeSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3) {
61612   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61613   Dali::Toolkit::StyleManager arg2 ;
61614   Dali::StyleChange::Type arg3 ;
61615   Dali::Toolkit::StyleManager *argp2 ;
61616
61617   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61618   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
61619   if (!argp2) {
61620     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
61621     return ;
61622   }
61623   arg2 = *argp2;
61624   arg3 = (Dali::StyleChange::Type)jarg3;
61625   {
61626     try {
61627       (arg1)->Dali::Toolkit::Internal::Control::OnStyleChange(arg2,arg3);
61628     } catch (std::out_of_range& e) {
61629       {
61630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
61631       };
61632     } catch (std::exception& e) {
61633       {
61634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
61635       };
61636     } catch (Dali::DaliException e) {
61637       {
61638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
61639       };
61640     } catch (...) {
61641       {
61642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
61643       };
61644     }
61645   }
61646
61647 }
61648
61649
61650 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivated(void * jarg1) {
61651   unsigned int jresult ;
61652   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61653   bool result;
61654
61655   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61656   {
61657     try {
61658       result = (bool)(arg1)->OnAccessibilityActivated();
61659     } catch (std::out_of_range& e) {
61660       {
61661         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61662       };
61663     } catch (std::exception& e) {
61664       {
61665         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61666       };
61667     } catch (Dali::DaliException e) {
61668       {
61669         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61670       };
61671     } catch (...) {
61672       {
61673         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61674       };
61675     }
61676   }
61677
61678   jresult = result;
61679   return jresult;
61680 }
61681
61682
61683 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityActivatedSwigExplicitViewImpl(void * jarg1) {
61684   unsigned int jresult ;
61685   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61686   bool result;
61687
61688   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61689   {
61690     try {
61691       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityActivated();
61692     } catch (std::out_of_range& e) {
61693       {
61694         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61695       };
61696     } catch (std::exception& e) {
61697       {
61698         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61699       };
61700     } catch (Dali::DaliException e) {
61701       {
61702         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61703       };
61704     } catch (...) {
61705       {
61706         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61707       };
61708     }
61709   }
61710
61711   jresult = result;
61712   return jresult;
61713 }
61714
61715
61716 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPan(void * jarg1, void * jarg2) {
61717   unsigned int jresult ;
61718   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61719   Dali::PanGesture arg2 ;
61720   Dali::PanGesture *argp2 ;
61721   bool result;
61722
61723   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61724   argp2 = (Dali::PanGesture *)jarg2;
61725   if (!argp2) {
61726     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61727     return 0;
61728   }
61729   arg2 = *argp2;
61730   {
61731     try {
61732       result = (bool)(arg1)->OnAccessibilityPan(arg2);
61733     } catch (std::out_of_range& e) {
61734       {
61735         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61736       };
61737     } catch (std::exception& e) {
61738       {
61739         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61740       };
61741     } catch (Dali::DaliException e) {
61742       {
61743         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61744       };
61745     } catch (...) {
61746       {
61747         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61748       };
61749     }
61750   }
61751
61752   jresult = result;
61753   return jresult;
61754 }
61755
61756
61757 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61758   unsigned int jresult ;
61759   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61760   Dali::PanGesture arg2 ;
61761   Dali::PanGesture *argp2 ;
61762   bool result;
61763
61764   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61765   argp2 = (Dali::PanGesture *)jarg2;
61766   if (!argp2) {
61767     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::PanGesture", 0);
61768     return 0;
61769   }
61770   arg2 = *argp2;
61771   {
61772     try {
61773       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityPan(arg2);
61774     } catch (std::out_of_range& e) {
61775       {
61776         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61777       };
61778     } catch (std::exception& e) {
61779       {
61780         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61781       };
61782     } catch (Dali::DaliException e) {
61783       {
61784         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61785       };
61786     } catch (...) {
61787       {
61788         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61789       };
61790     }
61791   }
61792
61793   jresult = result;
61794   return jresult;
61795 }
61796
61797
61798 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouch(void * jarg1, void * jarg2) {
61799   unsigned int jresult ;
61800   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61801   Dali::TouchEvent *arg2 = 0 ;
61802   bool result;
61803
61804   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61805   arg2 = (Dali::TouchEvent *)jarg2;
61806   if (!arg2) {
61807     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61808     return 0;
61809   }
61810   {
61811     try {
61812       result = (bool)(arg1)->OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61813     } catch (std::out_of_range& e) {
61814       {
61815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61816       };
61817     } catch (std::exception& e) {
61818       {
61819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61820       };
61821     } catch (Dali::DaliException e) {
61822       {
61823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61824       };
61825     } catch (...) {
61826       {
61827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61828       };
61829     }
61830   }
61831
61832   jresult = result;
61833   return jresult;
61834 }
61835
61836
61837 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityTouchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
61838   unsigned int jresult ;
61839   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61840   Dali::TouchEvent *arg2 = 0 ;
61841   bool result;
61842
61843   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61844   arg2 = (Dali::TouchEvent *)jarg2;
61845   if (!arg2) {
61846     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TouchEvent const & type is null", 0);
61847     return 0;
61848   }
61849   {
61850     try {
61851       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityTouch((Dali::TouchEvent const &)*arg2);
61852     } catch (std::out_of_range& e) {
61853       {
61854         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61855       };
61856     } catch (std::exception& e) {
61857       {
61858         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61859       };
61860     } catch (Dali::DaliException e) {
61861       {
61862         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61863       };
61864     } catch (...) {
61865       {
61866         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61867       };
61868     }
61869   }
61870
61871   jresult = result;
61872   return jresult;
61873 }
61874
61875
61876 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChange(void * jarg1, unsigned int jarg2) {
61877   unsigned int jresult ;
61878   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61879   bool arg2 ;
61880   bool result;
61881
61882   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61883   arg2 = jarg2 ? true : false;
61884   {
61885     try {
61886       result = (bool)(arg1)->OnAccessibilityValueChange(arg2);
61887     } catch (std::out_of_range& e) {
61888       {
61889         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61890       };
61891     } catch (std::exception& e) {
61892       {
61893         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61894       };
61895     } catch (Dali::DaliException e) {
61896       {
61897         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61898       };
61899     } catch (...) {
61900       {
61901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61902       };
61903     }
61904   }
61905
61906   jresult = result;
61907   return jresult;
61908 }
61909
61910
61911 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityValueChangeSwigExplicitViewImpl(void * jarg1, unsigned int jarg2) {
61912   unsigned int jresult ;
61913   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61914   bool arg2 ;
61915   bool result;
61916
61917   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61918   arg2 = jarg2 ? true : false;
61919   {
61920     try {
61921       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityValueChange(arg2);
61922     } catch (std::out_of_range& e) {
61923       {
61924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61925       };
61926     } catch (std::exception& e) {
61927       {
61928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61929       };
61930     } catch (Dali::DaliException e) {
61931       {
61932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61933       };
61934     } catch (...) {
61935       {
61936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61937       };
61938     }
61939   }
61940
61941   jresult = result;
61942   return jresult;
61943 }
61944
61945
61946 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoom(void * jarg1) {
61947   unsigned int jresult ;
61948   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61949   bool result;
61950
61951   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61952   {
61953     try {
61954       result = (bool)(arg1)->OnAccessibilityZoom();
61955     } catch (std::out_of_range& e) {
61956       {
61957         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61958       };
61959     } catch (std::exception& e) {
61960       {
61961         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61962       };
61963     } catch (Dali::DaliException e) {
61964       {
61965         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61966       };
61967     } catch (...) {
61968       {
61969         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
61970       };
61971     }
61972   }
61973
61974   jresult = result;
61975   return jresult;
61976 }
61977
61978
61979 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnAccessibilityZoomSwigExplicitViewImpl(void * jarg1) {
61980   unsigned int jresult ;
61981   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
61982   bool result;
61983
61984   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
61985   {
61986     try {
61987       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnAccessibilityZoom();
61988     } catch (std::out_of_range& e) {
61989       {
61990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
61991       };
61992     } catch (std::exception& e) {
61993       {
61994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
61995       };
61996     } catch (Dali::DaliException e) {
61997       {
61998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
61999       };
62000     } catch (...) {
62001       {
62002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62003       };
62004     }
62005   }
62006
62007   jresult = result;
62008   return jresult;
62009 }
62010
62011
62012 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGained(void * jarg1) {
62013   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62014
62015   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62016   {
62017     try {
62018       (arg1)->OnKeyInputFocusGained();
62019     } catch (std::out_of_range& e) {
62020       {
62021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62022       };
62023     } catch (std::exception& e) {
62024       {
62025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62026       };
62027     } catch (Dali::DaliException e) {
62028       {
62029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62030       };
62031     } catch (...) {
62032       {
62033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62034       };
62035     }
62036   }
62037
62038 }
62039
62040
62041 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusGainedSwigExplicitViewImpl(void * jarg1) {
62042   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62043
62044   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62045   {
62046     try {
62047       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusGained();
62048     } catch (std::out_of_range& e) {
62049       {
62050         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62051       };
62052     } catch (std::exception& e) {
62053       {
62054         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62055       };
62056     } catch (Dali::DaliException e) {
62057       {
62058         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62059       };
62060     } catch (...) {
62061       {
62062         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62063       };
62064     }
62065   }
62066
62067 }
62068
62069
62070 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLost(void * jarg1) {
62071   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62072
62073   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62074   {
62075     try {
62076       (arg1)->OnKeyInputFocusLost();
62077     } catch (std::out_of_range& e) {
62078       {
62079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62080       };
62081     } catch (std::exception& e) {
62082       {
62083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62084       };
62085     } catch (Dali::DaliException e) {
62086       {
62087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62088       };
62089     } catch (...) {
62090       {
62091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62092       };
62093     }
62094   }
62095
62096 }
62097
62098
62099 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyInputFocusLostSwigExplicitViewImpl(void * jarg1) {
62100   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62101
62102   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62103   {
62104     try {
62105       (arg1)->Dali::Toolkit::Internal::Control::OnKeyInputFocusLost();
62106     } catch (std::out_of_range& e) {
62107       {
62108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62109       };
62110     } catch (std::exception& e) {
62111       {
62112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62113       };
62114     } catch (Dali::DaliException e) {
62115       {
62116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62117       };
62118     } catch (...) {
62119       {
62120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62121       };
62122     }
62123   }
62124
62125 }
62126
62127
62128 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActor(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62129   void * jresult ;
62130   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62131   Dali::Actor arg2 ;
62132   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62133   bool arg4 ;
62134   Dali::Actor *argp2 ;
62135   Dali::Actor result;
62136
62137   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62138   argp2 = (Dali::Actor *)jarg2;
62139   if (!argp2) {
62140     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62141     return 0;
62142   }
62143   arg2 = *argp2;
62144   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62145   arg4 = jarg4 ? true : false;
62146   {
62147     try {
62148       result = (arg1)->GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62149     } catch (std::out_of_range& e) {
62150       {
62151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62152       };
62153     } catch (std::exception& e) {
62154       {
62155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62156       };
62157     } catch (Dali::DaliException e) {
62158       {
62159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62160       };
62161     } catch (...) {
62162       {
62163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62164       };
62165     }
62166   }
62167
62168   jresult = new Dali::Actor((const Dali::Actor &)result);
62169   return jresult;
62170 }
62171
62172
62173 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ViewImpl_GetNextKeyboardFocusableActorSwigExplicitViewImpl(void * jarg1, void * jarg2, int jarg3, unsigned int jarg4) {
62174   void * jresult ;
62175   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62176   Dali::Actor arg2 ;
62177   Dali::Toolkit::Control::KeyboardFocus::Direction arg3 ;
62178   bool arg4 ;
62179   Dali::Actor *argp2 ;
62180   Dali::Actor result;
62181
62182   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62183   argp2 = (Dali::Actor *)jarg2;
62184   if (!argp2) {
62185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62186     return 0;
62187   }
62188   arg2 = *argp2;
62189   arg3 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg3;
62190   arg4 = jarg4 ? true : false;
62191   {
62192     try {
62193       result = (arg1)->Dali::Toolkit::Internal::Control::GetNextKeyboardFocusableActor(arg2,arg3,arg4);
62194     } catch (std::out_of_range& e) {
62195       {
62196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62197       };
62198     } catch (std::exception& e) {
62199       {
62200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62201       };
62202     } catch (Dali::DaliException e) {
62203       {
62204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62205       };
62206     } catch (...) {
62207       {
62208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62209       };
62210     }
62211   }
62212
62213   jresult = new Dali::Actor((const Dali::Actor &)result);
62214   return jresult;
62215 }
62216
62217
62218 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommitted(void * jarg1, void * jarg2) {
62219   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62220   Dali::Actor arg2 ;
62221   Dali::Actor *argp2 ;
62222
62223   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62224   argp2 = (Dali::Actor *)jarg2;
62225   if (!argp2) {
62226     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62227     return ;
62228   }
62229   arg2 = *argp2;
62230   {
62231     try {
62232       (arg1)->OnKeyboardFocusChangeCommitted(arg2);
62233     } catch (std::out_of_range& e) {
62234       {
62235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62236       };
62237     } catch (std::exception& e) {
62238       {
62239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62240       };
62241     } catch (Dali::DaliException e) {
62242       {
62243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62244       };
62245     } catch (...) {
62246       {
62247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62248       };
62249     }
62250   }
62251
62252 }
62253
62254
62255 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardFocusChangeCommittedSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62256   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62257   Dali::Actor arg2 ;
62258   Dali::Actor *argp2 ;
62259
62260   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62261   argp2 = (Dali::Actor *)jarg2;
62262   if (!argp2) {
62263     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
62264     return ;
62265   }
62266   arg2 = *argp2;
62267   {
62268     try {
62269       (arg1)->Dali::Toolkit::Internal::Control::OnKeyboardFocusChangeCommitted(arg2);
62270     } catch (std::out_of_range& e) {
62271       {
62272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62273       };
62274     } catch (std::exception& e) {
62275       {
62276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62277       };
62278     } catch (Dali::DaliException e) {
62279       {
62280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62281       };
62282     } catch (...) {
62283       {
62284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62285       };
62286     }
62287   }
62288
62289 }
62290
62291
62292 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnter(void * jarg1) {
62293   unsigned int jresult ;
62294   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62295   bool result;
62296
62297   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62298   {
62299     try {
62300       result = (bool)(arg1)->OnKeyboardEnter();
62301     } catch (std::out_of_range& e) {
62302       {
62303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62304       };
62305     } catch (std::exception& e) {
62306       {
62307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62308       };
62309     } catch (Dali::DaliException e) {
62310       {
62311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62312       };
62313     } catch (...) {
62314       {
62315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62316       };
62317     }
62318   }
62319
62320   jresult = result;
62321   return jresult;
62322 }
62323
62324
62325 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewImpl_OnKeyboardEnterSwigExplicitViewImpl(void * jarg1) {
62326   unsigned int jresult ;
62327   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62328   bool result;
62329
62330   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62331   {
62332     try {
62333       result = (bool)(arg1)->Dali::Toolkit::Internal::Control::OnKeyboardEnter();
62334     } catch (std::out_of_range& e) {
62335       {
62336         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62337       };
62338     } catch (std::exception& e) {
62339       {
62340         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62341       };
62342     } catch (Dali::DaliException e) {
62343       {
62344         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62345       };
62346     } catch (...) {
62347       {
62348         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62349       };
62350     }
62351   }
62352
62353   jresult = result;
62354   return jresult;
62355 }
62356
62357
62358 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinch(void * jarg1, void * jarg2) {
62359   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62360   Dali::PinchGesture *arg2 = 0 ;
62361
62362   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62363   arg2 = (Dali::PinchGesture *)jarg2;
62364   if (!arg2) {
62365     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62366     return ;
62367   }
62368   {
62369     try {
62370       (arg1)->OnPinch((Dali::PinchGesture const &)*arg2);
62371     } catch (std::out_of_range& e) {
62372       {
62373         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62374       };
62375     } catch (std::exception& e) {
62376       {
62377         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62378       };
62379     } catch (Dali::DaliException e) {
62380       {
62381         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62382       };
62383     } catch (...) {
62384       {
62385         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62386       };
62387     }
62388   }
62389
62390 }
62391
62392
62393 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPinchSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62394   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62395   Dali::PinchGesture *arg2 = 0 ;
62396
62397   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62398   arg2 = (Dali::PinchGesture *)jarg2;
62399   if (!arg2) {
62400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PinchGesture const & type is null", 0);
62401     return ;
62402   }
62403   {
62404     try {
62405       (arg1)->Dali::Toolkit::Internal::Control::OnPinch((Dali::PinchGesture const &)*arg2);
62406     } catch (std::out_of_range& e) {
62407       {
62408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62409       };
62410     } catch (std::exception& e) {
62411       {
62412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62413       };
62414     } catch (Dali::DaliException e) {
62415       {
62416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62417       };
62418     } catch (...) {
62419       {
62420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62421       };
62422     }
62423   }
62424
62425 }
62426
62427
62428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPan(void * jarg1, void * jarg2) {
62429   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62430   Dali::PanGesture *arg2 = 0 ;
62431
62432   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62433   arg2 = (Dali::PanGesture *)jarg2;
62434   if (!arg2) {
62435     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62436     return ;
62437   }
62438   {
62439     try {
62440       (arg1)->OnPan((Dali::PanGesture const &)*arg2);
62441     } catch (std::out_of_range& e) {
62442       {
62443         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62444       };
62445     } catch (std::exception& e) {
62446       {
62447         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62448       };
62449     } catch (Dali::DaliException e) {
62450       {
62451         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62452       };
62453     } catch (...) {
62454       {
62455         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62456       };
62457     }
62458   }
62459
62460 }
62461
62462
62463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnPanSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62464   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62465   Dali::PanGesture *arg2 = 0 ;
62466
62467   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62468   arg2 = (Dali::PanGesture *)jarg2;
62469   if (!arg2) {
62470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::PanGesture const & type is null", 0);
62471     return ;
62472   }
62473   {
62474     try {
62475       (arg1)->Dali::Toolkit::Internal::Control::OnPan((Dali::PanGesture const &)*arg2);
62476     } catch (std::out_of_range& e) {
62477       {
62478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62479       };
62480     } catch (std::exception& e) {
62481       {
62482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62483       };
62484     } catch (Dali::DaliException e) {
62485       {
62486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62487       };
62488     } catch (...) {
62489       {
62490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62491       };
62492     }
62493   }
62494
62495 }
62496
62497
62498 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTap(void * jarg1, void * jarg2) {
62499   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62500   Dali::TapGesture *arg2 = 0 ;
62501
62502   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62503   arg2 = (Dali::TapGesture *)jarg2;
62504   if (!arg2) {
62505     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62506     return ;
62507   }
62508   {
62509     try {
62510       (arg1)->OnTap((Dali::TapGesture const &)*arg2);
62511     } catch (std::out_of_range& e) {
62512       {
62513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62514       };
62515     } catch (std::exception& e) {
62516       {
62517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62518       };
62519     } catch (Dali::DaliException e) {
62520       {
62521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62522       };
62523     } catch (...) {
62524       {
62525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62526       };
62527     }
62528   }
62529
62530 }
62531
62532
62533 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnTapSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62534   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62535   Dali::TapGesture *arg2 = 0 ;
62536
62537   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62538   arg2 = (Dali::TapGesture *)jarg2;
62539   if (!arg2) {
62540     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::TapGesture const & type is null", 0);
62541     return ;
62542   }
62543   {
62544     try {
62545       (arg1)->Dali::Toolkit::Internal::Control::OnTap((Dali::TapGesture const &)*arg2);
62546     } catch (std::out_of_range& e) {
62547       {
62548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62549       };
62550     } catch (std::exception& e) {
62551       {
62552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62553       };
62554     } catch (Dali::DaliException e) {
62555       {
62556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62557       };
62558     } catch (...) {
62559       {
62560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62561       };
62562     }
62563   }
62564
62565 }
62566
62567
62568 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPress(void * jarg1, void * jarg2) {
62569   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62570   Dali::LongPressGesture *arg2 = 0 ;
62571
62572   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62573   arg2 = (Dali::LongPressGesture *)jarg2;
62574   if (!arg2) {
62575     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62576     return ;
62577   }
62578   {
62579     try {
62580       (arg1)->OnLongPress((Dali::LongPressGesture const &)*arg2);
62581     } catch (std::out_of_range& e) {
62582       {
62583         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62584       };
62585     } catch (std::exception& e) {
62586       {
62587         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62588       };
62589     } catch (Dali::DaliException e) {
62590       {
62591         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62592       };
62593     } catch (...) {
62594       {
62595         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62596       };
62597     }
62598   }
62599
62600 }
62601
62602
62603 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_OnLongPressSwigExplicitViewImpl(void * jarg1, void * jarg2) {
62604   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62605   Dali::LongPressGesture *arg2 = 0 ;
62606
62607   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62608   arg2 = (Dali::LongPressGesture *)jarg2;
62609   if (!arg2) {
62610     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::LongPressGesture const & type is null", 0);
62611     return ;
62612   }
62613   {
62614     try {
62615       (arg1)->Dali::Toolkit::Internal::Control::OnLongPress((Dali::LongPressGesture const &)*arg2);
62616     } catch (std::out_of_range& e) {
62617       {
62618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62619       };
62620     } catch (std::exception& e) {
62621       {
62622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62623       };
62624     } catch (Dali::DaliException e) {
62625       {
62626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62627       };
62628     } catch (...) {
62629       {
62630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62631       };
62632     }
62633   }
62634
62635 }
62636
62637
62638 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
62639   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62640   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62641   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62642
62643   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62644   arg2 = (Dali::SlotObserver *)jarg2;
62645   arg3 = (Dali::CallbackBase *)jarg3;
62646   {
62647     try {
62648       (arg1)->SignalConnected(arg2,arg3);
62649     } catch (std::out_of_range& e) {
62650       {
62651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62652       };
62653     } catch (std::exception& e) {
62654       {
62655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62656       };
62657     } catch (Dali::DaliException e) {
62658       {
62659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62660       };
62661     } catch (...) {
62662       {
62663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62664       };
62665     }
62666   }
62667
62668 }
62669
62670
62671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalConnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62672   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62673   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62674   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62675
62676   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62677   arg2 = (Dali::SlotObserver *)jarg2;
62678   arg3 = (Dali::CallbackBase *)jarg3;
62679   {
62680     try {
62681       (arg1)->Dali::Toolkit::Internal::Control::SignalConnected(arg2,arg3);
62682     } catch (std::out_of_range& e) {
62683       {
62684         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62685       };
62686     } catch (std::exception& e) {
62687       {
62688         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62689       };
62690     } catch (Dali::DaliException e) {
62691       {
62692         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62693       };
62694     } catch (...) {
62695       {
62696         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62697       };
62698     }
62699   }
62700
62701 }
62702
62703
62704 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
62705   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62706   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62707   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62708
62709   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62710   arg2 = (Dali::SlotObserver *)jarg2;
62711   arg3 = (Dali::CallbackBase *)jarg3;
62712   {
62713     try {
62714       (arg1)->SignalDisconnected(arg2,arg3);
62715     } catch (std::out_of_range& e) {
62716       {
62717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62718       };
62719     } catch (std::exception& e) {
62720       {
62721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62722       };
62723     } catch (Dali::DaliException e) {
62724       {
62725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62726       };
62727     } catch (...) {
62728       {
62729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62730       };
62731     }
62732   }
62733
62734 }
62735
62736
62737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewImpl_SignalDisconnectedSwigExplicitViewImpl(void * jarg1, void * jarg2, void * jarg3) {
62738   Dali::Toolkit::Internal::Control *arg1 = (Dali::Toolkit::Internal::Control *) 0 ;
62739   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
62740   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
62741
62742   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
62743   arg2 = (Dali::SlotObserver *)jarg2;
62744   arg3 = (Dali::CallbackBase *)jarg3;
62745   {
62746     try {
62747       (arg1)->Dali::Toolkit::Internal::Control::SignalDisconnected(arg2,arg3);
62748     } catch (std::out_of_range& e) {
62749       {
62750         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62751       };
62752     } catch (std::exception& e) {
62753       {
62754         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62755       };
62756     } catch (Dali::DaliException e) {
62757       {
62758         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62759       };
62760     } catch (...) {
62761       {
62762         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62763       };
62764     }
62765   }
62766
62767 }
62768
62769
62770 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) {
62771   Dali::Toolkit::Internal::Control *obj = (Dali::Toolkit::Internal::Control *)objarg;
62772   SwigDirector_ViewImpl *director = dynamic_cast<SwigDirector_ViewImpl *>(obj);
62773   if (director) {
62774     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);
62775   }
62776 }
62777
62778
62779 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetImplementation__SWIG_0(void * jarg1) {
62780   void * jresult ;
62781   Dali::Toolkit::Control *arg1 = 0 ;
62782   Dali::Toolkit::Internal::Control *result = 0 ;
62783
62784   arg1 = (Dali::Toolkit::Control *)jarg1;
62785   if (!arg1) {
62786     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
62787     return 0;
62788   }
62789   {
62790     try {
62791       result = (Dali::Toolkit::Internal::Control *) &Dali::Toolkit::Internal::GetImplementation(*arg1);
62792     } catch (std::out_of_range& e) {
62793       {
62794         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62795       };
62796     } catch (std::exception& e) {
62797       {
62798         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62799       };
62800     } catch (Dali::DaliException e) {
62801       {
62802         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62803       };
62804     } catch (...) {
62805       {
62806         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62807       };
62808     }
62809   }
62810
62811   jresult = (void *)result;
62812   return jresult;
62813 }
62814
62815
62816 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_STYLE_NAME_get() {
62817   int jresult ;
62818   int result;
62819
62820   result = (int)Dali::Toolkit::Control::Property::STYLE_NAME;
62821   jresult = (int)result;
62822   return jresult;
62823 }
62824
62825 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_KEY_INPUT_FOCUS_get() {
62826   int jresult ;
62827   int result;
62828
62829   result = (int)Dali::Toolkit::Control::Property::KEY_INPUT_FOCUS;
62830   jresult = (int)result;
62831   return jresult;
62832 }
62833
62834
62835 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_BACKGROUND_get() {
62836   int jresult ;
62837   int result;
62838
62839   result = (int)Dali::Toolkit::Control::Property::BACKGROUND;
62840   jresult = (int)result;
62841   return jresult;
62842 }
62843
62844 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_MARGIN_get() {
62845   int jresult ;
62846   int result;
62847
62848   result = (int)Dali::Toolkit::Control::Property::MARGIN;
62849   jresult = (int)result;
62850   return jresult;
62851 }
62852
62853
62854 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_PADDING_get() {
62855   int jresult ;
62856   int result;
62857
62858   result = (int)Dali::Toolkit::Control::Property::PADDING;
62859   jresult = (int)result;
62860   return jresult;
62861 }
62862
62863 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_Property_SHADOW_get() {
62864   int jresult ;
62865   int result;
62866
62867   result = (int)Dali::Toolkit::DevelControl::Property::SHADOW;
62868   jresult = (int)result;
62869   return jresult;
62870 }
62871
62872 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_Property() {
62873   void * jresult ;
62874   Dali::Toolkit::Control::Property *result = 0 ;
62875
62876   {
62877     try {
62878       result = (Dali::Toolkit::Control::Property *)new Dali::Toolkit::Control::Property();
62879     } catch (std::out_of_range& e) {
62880       {
62881         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62882       };
62883     } catch (std::exception& e) {
62884       {
62885         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62886       };
62887     } catch (Dali::DaliException e) {
62888       {
62889         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62890       };
62891     } catch (...) {
62892       {
62893         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62894       };
62895     }
62896   }
62897
62898   jresult = (void *)result;
62899   return jresult;
62900 }
62901
62902
62903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_Property(void * jarg1) {
62904   Dali::Toolkit::Control::Property *arg1 = (Dali::Toolkit::Control::Property *) 0 ;
62905
62906   arg1 = (Dali::Toolkit::Control::Property *)jarg1;
62907   {
62908     try {
62909       delete arg1;
62910     } catch (std::out_of_range& e) {
62911       {
62912         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62913       };
62914     } catch (std::exception& e) {
62915       {
62916         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62917       };
62918     } catch (Dali::DaliException e) {
62919       {
62920         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62921       };
62922     } catch (...) {
62923       {
62924         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62925       };
62926     }
62927   }
62928
62929 }
62930
62931
62932 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View_KeyboardFocus() {
62933   void * jresult ;
62934   Dali::Toolkit::Control::KeyboardFocus *result = 0 ;
62935
62936   {
62937     try {
62938       result = (Dali::Toolkit::Control::KeyboardFocus *)new Dali::Toolkit::Control::KeyboardFocus();
62939     } catch (std::out_of_range& e) {
62940       {
62941         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
62942       };
62943     } catch (std::exception& e) {
62944       {
62945         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
62946       };
62947     } catch (Dali::DaliException e) {
62948       {
62949         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
62950       };
62951     } catch (...) {
62952       {
62953         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
62954       };
62955     }
62956   }
62957
62958   jresult = (void *)result;
62959   return jresult;
62960 }
62961
62962
62963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View_KeyboardFocus(void * jarg1) {
62964   Dali::Toolkit::Control::KeyboardFocus *arg1 = (Dali::Toolkit::Control::KeyboardFocus *) 0 ;
62965
62966   arg1 = (Dali::Toolkit::Control::KeyboardFocus *)jarg1;
62967   {
62968     try {
62969       delete arg1;
62970     } catch (std::out_of_range& e) {
62971       {
62972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
62973       };
62974     } catch (std::exception& e) {
62975       {
62976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
62977       };
62978     } catch (Dali::DaliException e) {
62979       {
62980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
62981       };
62982     } catch (...) {
62983       {
62984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
62985       };
62986     }
62987   }
62988
62989 }
62990
62991
62992 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_New() {
62993   void * jresult ;
62994   Dali::Toolkit::Control result;
62995
62996   {
62997     try {
62998       result = Dali::Toolkit::Control::New();
62999     } catch (std::out_of_range& e) {
63000       {
63001         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63002       };
63003     } catch (std::exception& e) {
63004       {
63005         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63006       };
63007     } catch (Dali::DaliException e) {
63008       {
63009         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63010       };
63011     } catch (...) {
63012       {
63013         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63014       };
63015     }
63016   }
63017
63018   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63019   return jresult;
63020 }
63021
63022
63023 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_0() {
63024   void * jresult ;
63025   Dali::Toolkit::Control *result = 0 ;
63026
63027   {
63028     try {
63029       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control();
63030     } catch (std::out_of_range& e) {
63031       {
63032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63033       };
63034     } catch (std::exception& e) {
63035       {
63036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63037       };
63038     } catch (Dali::DaliException e) {
63039       {
63040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63041       };
63042     } catch (...) {
63043       {
63044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63045       };
63046     }
63047   }
63048
63049   jresult = (void *)result;
63050   return jresult;
63051 }
63052
63053
63054 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_View__SWIG_1(void * jarg1) {
63055   void * jresult ;
63056   Dali::Toolkit::Control *arg1 = 0 ;
63057   Dali::Toolkit::Control *result = 0 ;
63058
63059   arg1 = (Dali::Toolkit::Control *)jarg1;
63060   if (!arg1) {
63061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63062     return 0;
63063   }
63064   {
63065     try {
63066       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control((Dali::Toolkit::Control const &)*arg1);
63067     } catch (std::out_of_range& e) {
63068       {
63069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63070       };
63071     } catch (std::exception& e) {
63072       {
63073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63074       };
63075     } catch (Dali::DaliException e) {
63076       {
63077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63078       };
63079     } catch (...) {
63080       {
63081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63082       };
63083     }
63084   }
63085
63086   jresult = (void *)result;
63087   return jresult;
63088 }
63089
63090
63091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_View(void * jarg1) {
63092   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63093
63094   arg1 = (Dali::Toolkit::Control *)jarg1;
63095   {
63096     try {
63097       delete arg1;
63098     } catch (std::out_of_range& e) {
63099       {
63100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63101       };
63102     } catch (std::exception& e) {
63103       {
63104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63105       };
63106     } catch (Dali::DaliException e) {
63107       {
63108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63109       };
63110     } catch (...) {
63111       {
63112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63113       };
63114     }
63115   }
63116
63117 }
63118
63119
63120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_Assign(void * jarg1, void * jarg2) {
63121   void * jresult ;
63122   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63123   Dali::Toolkit::Control *arg2 = 0 ;
63124   Dali::Toolkit::Control *result = 0 ;
63125
63126   arg1 = (Dali::Toolkit::Control *)jarg1;
63127   arg2 = (Dali::Toolkit::Control *)jarg2;
63128   if (!arg2) {
63129     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63130     return 0;
63131   }
63132   {
63133     try {
63134       result = (Dali::Toolkit::Control *) &(arg1)->operator =((Dali::Toolkit::Control const &)*arg2);
63135     } catch (std::out_of_range& e) {
63136       {
63137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63138       };
63139     } catch (std::exception& e) {
63140       {
63141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63142       };
63143     } catch (Dali::DaliException e) {
63144       {
63145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63146       };
63147     } catch (...) {
63148       {
63149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63150       };
63151     }
63152   }
63153
63154   jresult = (void *)result;
63155   return jresult;
63156 }
63157
63158
63159 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_DownCast(void * jarg1) {
63160   void * jresult ;
63161   Dali::BaseHandle arg1 ;
63162   Dali::BaseHandle *argp1 ;
63163   Dali::Toolkit::Control result;
63164
63165   argp1 = (Dali::BaseHandle *)jarg1;
63166   if (!argp1) {
63167     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
63168     return 0;
63169   }
63170   arg1 = *argp1;
63171   {
63172     try {
63173       result = Dali::Toolkit::Control::DownCast(arg1);
63174     } catch (std::out_of_range& e) {
63175       {
63176         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63177       };
63178     } catch (std::exception& e) {
63179       {
63180         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63181       };
63182     } catch (Dali::DaliException e) {
63183       {
63184         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63185       };
63186     } catch (...) {
63187       {
63188         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63189       };
63190     }
63191   }
63192
63193   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
63194   return jresult;
63195 }
63196
63197
63198 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetKeyInputFocus(void * jarg1) {
63199   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63200
63201   arg1 = (Dali::Toolkit::Control *)jarg1;
63202   {
63203     try {
63204       (arg1)->SetKeyInputFocus();
63205     } catch (std::out_of_range& e) {
63206       {
63207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63208       };
63209     } catch (std::exception& e) {
63210       {
63211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63212       };
63213     } catch (Dali::DaliException e) {
63214       {
63215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63216       };
63217     } catch (...) {
63218       {
63219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63220       };
63221     }
63222   }
63223
63224 }
63225
63226
63227 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_View_HasKeyInputFocus(void * jarg1) {
63228   unsigned int jresult ;
63229   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63230   bool result;
63231
63232   arg1 = (Dali::Toolkit::Control *)jarg1;
63233   {
63234     try {
63235       result = (bool)(arg1)->HasKeyInputFocus();
63236     } catch (std::out_of_range& e) {
63237       {
63238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63239       };
63240     } catch (std::exception& e) {
63241       {
63242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63243       };
63244     } catch (Dali::DaliException e) {
63245       {
63246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63247       };
63248     } catch (...) {
63249       {
63250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63251       };
63252     }
63253   }
63254
63255   jresult = result;
63256   return jresult;
63257 }
63258
63259
63260 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearKeyInputFocus(void * jarg1) {
63261   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63262
63263   arg1 = (Dali::Toolkit::Control *)jarg1;
63264   {
63265     try {
63266       (arg1)->ClearKeyInputFocus();
63267     } catch (std::out_of_range& e) {
63268       {
63269         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63270       };
63271     } catch (std::exception& e) {
63272       {
63273         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63274       };
63275     } catch (Dali::DaliException e) {
63276       {
63277         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63278       };
63279     } catch (...) {
63280       {
63281         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63282       };
63283     }
63284   }
63285
63286 }
63287
63288
63289 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPinchGestureDetector(void * jarg1) {
63290   void * jresult ;
63291   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63292   Dali::PinchGestureDetector result;
63293
63294   arg1 = (Dali::Toolkit::Control *)jarg1;
63295   {
63296     try {
63297       result = ((Dali::Toolkit::Control const *)arg1)->GetPinchGestureDetector();
63298     } catch (std::out_of_range& e) {
63299       {
63300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63301       };
63302     } catch (std::exception& e) {
63303       {
63304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63305       };
63306     } catch (Dali::DaliException e) {
63307       {
63308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63309       };
63310     } catch (...) {
63311       {
63312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63313       };
63314     }
63315   }
63316
63317   jresult = new Dali::PinchGestureDetector((const Dali::PinchGestureDetector &)result);
63318   return jresult;
63319 }
63320
63321
63322 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetPanGestureDetector(void * jarg1) {
63323   void * jresult ;
63324   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63325   Dali::PanGestureDetector result;
63326
63327   arg1 = (Dali::Toolkit::Control *)jarg1;
63328   {
63329     try {
63330       result = ((Dali::Toolkit::Control const *)arg1)->GetPanGestureDetector();
63331     } catch (std::out_of_range& e) {
63332       {
63333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63334       };
63335     } catch (std::exception& e) {
63336       {
63337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63338       };
63339     } catch (Dali::DaliException e) {
63340       {
63341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63342       };
63343     } catch (...) {
63344       {
63345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63346       };
63347     }
63348   }
63349
63350   jresult = new Dali::PanGestureDetector((const Dali::PanGestureDetector &)result);
63351   return jresult;
63352 }
63353
63354
63355 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetTapGestureDetector(void * jarg1) {
63356   void * jresult ;
63357   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63358   Dali::TapGestureDetector result;
63359
63360   arg1 = (Dali::Toolkit::Control *)jarg1;
63361   {
63362     try {
63363       result = ((Dali::Toolkit::Control const *)arg1)->GetTapGestureDetector();
63364     } catch (std::out_of_range& e) {
63365       {
63366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63367       };
63368     } catch (std::exception& e) {
63369       {
63370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63371       };
63372     } catch (Dali::DaliException e) {
63373       {
63374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63375       };
63376     } catch (...) {
63377       {
63378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63379       };
63380     }
63381   }
63382
63383   jresult = new Dali::TapGestureDetector((const Dali::TapGestureDetector &)result);
63384   return jresult;
63385 }
63386
63387
63388 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_GetLongPressGestureDetector(void * jarg1) {
63389   void * jresult ;
63390   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63391   Dali::LongPressGestureDetector result;
63392
63393   arg1 = (Dali::Toolkit::Control *)jarg1;
63394   {
63395     try {
63396       result = ((Dali::Toolkit::Control const *)arg1)->GetLongPressGestureDetector();
63397     } catch (std::out_of_range& e) {
63398       {
63399         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63400       };
63401     } catch (std::exception& e) {
63402       {
63403         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63404       };
63405     } catch (Dali::DaliException e) {
63406       {
63407         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63408       };
63409     } catch (...) {
63410       {
63411         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63412       };
63413     }
63414   }
63415
63416   jresult = new Dali::LongPressGestureDetector((const Dali::LongPressGestureDetector &)result);
63417   return jresult;
63418 }
63419
63420
63421 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetStyleName(void * jarg1, char * jarg2) {
63422   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63423   std::string *arg2 = 0 ;
63424
63425   arg1 = (Dali::Toolkit::Control *)jarg1;
63426   if (!jarg2) {
63427     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
63428     return ;
63429   }
63430   std::string arg2_str(jarg2);
63431   arg2 = &arg2_str;
63432   {
63433     try {
63434       (arg1)->SetStyleName((std::string const &)*arg2);
63435     } catch (std::out_of_range& e) {
63436       {
63437         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63438       };
63439     } catch (std::exception& e) {
63440       {
63441         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63442       };
63443     } catch (Dali::DaliException e) {
63444       {
63445         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63446       };
63447     } catch (...) {
63448       {
63449         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63450       };
63451     }
63452   }
63453
63454
63455   //argout typemap for const std::string&
63456
63457 }
63458
63459
63460 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_View_GetStyleName(void * jarg1) {
63461   char * jresult ;
63462   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63463   std::string *result = 0 ;
63464
63465   arg1 = (Dali::Toolkit::Control *)jarg1;
63466   {
63467     try {
63468       result = (std::string *) &((Dali::Toolkit::Control const *)arg1)->GetStyleName();
63469     } catch (std::out_of_range& e) {
63470       {
63471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63472       };
63473     } catch (std::exception& e) {
63474       {
63475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63476       };
63477     } catch (Dali::DaliException e) {
63478       {
63479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63480       };
63481     } catch (...) {
63482       {
63483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63484       };
63485     }
63486   }
63487
63488   jresult = SWIG_csharp_string_callback(result->c_str());
63489   return jresult;
63490 }
63491
63492
63493 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_SetBackgroundColor(void * jarg1, void * jarg2) {
63494   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63495   Dali::Vector4 *arg2 = 0 ;
63496
63497   arg1 = (Dali::Toolkit::Control *)jarg1;
63498   arg2 = (Dali::Vector4 *)jarg2;
63499   if (!arg2) {
63500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
63501     return ;
63502   }
63503   {
63504     try {
63505       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
63506     } catch (std::out_of_range& e) {
63507       {
63508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63509       };
63510     } catch (std::exception& e) {
63511       {
63512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63513       };
63514     } catch (Dali::DaliException e) {
63515       {
63516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63517       };
63518     } catch (...) {
63519       {
63520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63521       };
63522     }
63523   }
63524
63525 }
63526
63527 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_ClearBackground(void * jarg1) {
63528   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63529
63530   arg1 = (Dali::Toolkit::Control *)jarg1;
63531   {
63532     try {
63533       (arg1)->ClearBackground();
63534     } catch (std::out_of_range& e) {
63535       {
63536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63537       };
63538     } catch (std::exception& e) {
63539       {
63540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63541       };
63542     } catch (Dali::DaliException e) {
63543       {
63544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63545       };
63546     } catch (...) {
63547       {
63548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63549       };
63550     }
63551   }
63552
63553 }
63554
63555
63556 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyEventSignal(void * jarg1) {
63557   void * jresult ;
63558   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63559   Dali::Toolkit::Control::KeyEventSignalType *result = 0 ;
63560
63561   arg1 = (Dali::Toolkit::Control *)jarg1;
63562   {
63563     try {
63564       result = (Dali::Toolkit::Control::KeyEventSignalType *) &(arg1)->KeyEventSignal();
63565     } catch (std::out_of_range& e) {
63566       {
63567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63568       };
63569     } catch (std::exception& e) {
63570       {
63571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63572       };
63573     } catch (Dali::DaliException e) {
63574       {
63575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63576       };
63577     } catch (...) {
63578       {
63579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63580       };
63581     }
63582   }
63583
63584   jresult = (void *)result;
63585   return jresult;
63586 }
63587
63588
63589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusGainedSignal(void * jarg1) {
63590   void * jresult ;
63591   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63592   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63593
63594   arg1 = (Dali::Toolkit::Control *)jarg1;
63595   {
63596     try {
63597       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusGainedSignal();
63598     } catch (std::out_of_range& e) {
63599       {
63600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63601       };
63602     } catch (std::exception& e) {
63603       {
63604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63605       };
63606     } catch (Dali::DaliException e) {
63607       {
63608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63609       };
63610     } catch (...) {
63611       {
63612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63613       };
63614     }
63615   }
63616
63617   jresult = (void *)result;
63618   return jresult;
63619 }
63620
63621
63622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_KeyInputFocusLostSignal(void * jarg1) {
63623   void * jresult ;
63624   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63625   Dali::Toolkit::Control::KeyInputFocusSignalType *result = 0 ;
63626
63627   arg1 = (Dali::Toolkit::Control *)jarg1;
63628   {
63629     try {
63630       result = (Dali::Toolkit::Control::KeyInputFocusSignalType *) &(arg1)->KeyInputFocusLostSignal();
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_new_View__SWIG_2(void * jarg1) {
63656   void * jresult ;
63657   Dali::Toolkit::Internal::Control *arg1 = 0 ;
63658   Dali::Toolkit::Control *result = 0 ;
63659
63660   arg1 = (Dali::Toolkit::Internal::Control *)jarg1;
63661   if (!arg1) {
63662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Internal::Control & type is null", 0);
63663     return 0;
63664   }
63665   {
63666     try {
63667       result = (Dali::Toolkit::Control *)new Dali::Toolkit::Control(*arg1);
63668     } catch (std::out_of_range& e) {
63669       {
63670         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63671       };
63672     } catch (std::exception& e) {
63673       {
63674         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63675       };
63676     } catch (Dali::DaliException e) {
63677       {
63678         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63679       };
63680     } catch (...) {
63681       {
63682         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63683       };
63684     }
63685   }
63686
63687   jresult = (void *)result;
63688   return jresult;
63689 }
63690
63691 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_View_GetVisualResourceStatus(void * jarg1, int jarg2)
63692 {
63693   int jresult;
63694   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63695   arg1 = (Dali::Toolkit::Control *)jarg1;
63696
63697   if (!arg1) {
63698     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63699     return 0;
63700   }
63701
63702   Dali::Property::Index arg2 = 0 ;
63703   arg2 = (Dali::Property::Index)jarg2;
63704
63705   Toolkit::Visual::ResourceStatus result;
63706   {
63707     try {
63708       result = arg1->GetVisualResourceStatus(arg2);
63709     } catch (std::out_of_range& e) {
63710       {
63711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63712       };
63713     } catch (std::exception& e) {
63714       {
63715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63716       };
63717     } catch (...) {
63718       {
63719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63720       };
63721     }
63722   }
63723   jresult = (int)(result);
63724   return jresult;
63725 }
63726
63727 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_View_CreateTransition(void * jarg1, void * jarg2)
63728 {
63729   void * jresult;
63730   Dali::Toolkit::Control *arg1 = (Dali::Toolkit::Control *) 0 ;
63731   arg1 = (Dali::Toolkit::Control *)jarg1;
63732
63733   Dali::Toolkit::Internal::Control& controlImpl = Dali::Toolkit::Internal::GetImplementation( *arg1 );
63734
63735   Dali::Toolkit::TransitionData *arg2 = 0 ;
63736   Dali::Animation result;
63737
63738   arg2 = (Dali::Toolkit::TransitionData *)jarg2;
63739   if (!arg2) {
63740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TransitionData const & type is null", 0);
63741     return 0;
63742   }
63743   {
63744     try {
63745       result = DevelControl::CreateTransition( controlImpl, (Dali::Toolkit::TransitionData const &)*arg2);
63746     } catch (std::out_of_range& e) {
63747       {
63748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63749       };
63750     } catch (std::exception& e) {
63751       {
63752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63753       };
63754     } catch (Dali::DaliException e) {
63755       {
63756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63757       };
63758     } catch (...) {
63759       {
63760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63761       };
63762     }
63763   }
63764
63765   jresult = new Dali::Animation((const Dali::Animation &)result);
63766   return jresult;
63767 }
63768
63769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_View_DoAction(void * jarg1, int jarg2, int jarg3, void * jarg4 )
63770 {
63771   Dali::Toolkit::Control arg1;
63772   Dali::Toolkit::Control *argp1  = (Dali::Toolkit::Control *)jarg1;
63773
63774   if (!argp1) {
63775     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63776   }
63777   arg1 = *argp1;
63778
63779   Dali::Property::Index arg2 = 0 ;
63780   arg2 = (Dali::Property::Index)jarg2;
63781
63782   Dali::Property::Index arg3 = 0 ;
63783   arg3 = (Dali::Property::Index)jarg3;
63784
63785   Dali::Property::Value *arg4 = (Dali::Property::Value *)jarg4;
63786
63787   {
63788     try {
63789       DevelControl::DoAction(arg1, arg2, arg3, *arg4);
63790     } catch (std::out_of_range& e) {
63791       {
63792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63793       };
63794     } catch (std::exception& e) {
63795       {
63796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63797       };
63798     } catch (...) {
63799       {
63800         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63801       };
63802     }
63803   }
63804
63805
63806 }
63807
63808 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ResourceReadySignal(void * jarg1) {
63809   void * jresult ;
63810   Dali::Toolkit::Control *arg1 = 0 ;
63811   Dali::Toolkit::Control::ResourceReadySignalType *result = 0 ;
63812
63813   arg1 = (Dali::Toolkit::Control *)jarg1;
63814   if (!arg1) {
63815     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control & type is null", 0);
63816     return 0;
63817   }
63818   {
63819     try {
63820       result = (Dali::Toolkit::Control::ResourceReadySignalType *) &arg1->ResourceReadySignal();
63821     } catch (std::out_of_range& e) {
63822       {
63823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63824       };
63825     } catch (std::exception& e) {
63826       {
63827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63828       };
63829     } catch (Dali::DaliException e) {
63830       {
63831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63832       };
63833     } catch (...) {
63834       {
63835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63836       };
63837     }
63838   }
63839
63840   jresult = (void *)result;
63841   return jresult;
63842 }
63843
63844
63845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsResourceReady(void * jarg1) {
63846   unsigned int jresult ;
63847   Dali::Toolkit::Control *arg1 = 0 ;
63848   bool result;
63849
63850   arg1 = (Dali::Toolkit::Control *)jarg1;
63851   if (!arg1) {
63852     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Control const & type is null", 0);
63853     return 0;
63854   }
63855   {
63856     try {
63857       result = (bool)arg1->IsResourceReady();
63858     } catch (std::out_of_range& e) {
63859       {
63860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63861       };
63862     } catch (std::exception& e) {
63863       {
63864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63865       };
63866     } catch (Dali::DaliException e) {
63867       {
63868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63869       };
63870     } catch (...) {
63871       {
63872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63873       };
63874     }
63875   }
63876
63877   jresult = result;
63878   return jresult;
63879 }
63880
63881
63882 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_KeyInputFocusManager() {
63883   void * jresult ;
63884   Dali::Toolkit::KeyInputFocusManager *result = 0 ;
63885
63886   {
63887     try {
63888       result = (Dali::Toolkit::KeyInputFocusManager *)new Dali::Toolkit::KeyInputFocusManager();
63889     } catch (std::out_of_range& e) {
63890       {
63891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63892       };
63893     } catch (std::exception& e) {
63894       {
63895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63896       };
63897     } catch (Dali::DaliException e) {
63898       {
63899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63900       };
63901     } catch (...) {
63902       {
63903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63904       };
63905     }
63906   }
63907
63908   jresult = (void *)result;
63909   return jresult;
63910 }
63911
63912
63913 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusManager(void * jarg1) {
63914   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63915
63916   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63917   {
63918     try {
63919       delete arg1;
63920     } catch (std::out_of_range& e) {
63921       {
63922         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63923       };
63924     } catch (std::exception& e) {
63925       {
63926         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63927       };
63928     } catch (Dali::DaliException e) {
63929       {
63930         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63931       };
63932     } catch (...) {
63933       {
63934         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
63935       };
63936     }
63937   }
63938
63939 }
63940
63941
63942 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_Get() {
63943   void * jresult ;
63944   Dali::Toolkit::KeyInputFocusManager result;
63945
63946   {
63947     try {
63948       result = Dali::Toolkit::KeyInputFocusManager::Get();
63949     } catch (std::out_of_range& e) {
63950       {
63951         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
63952       };
63953     } catch (std::exception& e) {
63954       {
63955         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
63956       };
63957     } catch (Dali::DaliException e) {
63958       {
63959         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
63960       };
63961     } catch (...) {
63962       {
63963         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
63964       };
63965     }
63966   }
63967
63968   jresult = new Dali::Toolkit::KeyInputFocusManager((const Dali::Toolkit::KeyInputFocusManager &)result);
63969   return jresult;
63970 }
63971
63972
63973 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SetFocus(void * jarg1, void * jarg2) {
63974   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
63975   Dali::Toolkit::Control arg2 ;
63976   Dali::Toolkit::Control *argp2 ;
63977
63978   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
63979   argp2 = (Dali::Toolkit::Control *)jarg2;
63980   if (!argp2) {
63981     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
63982     return ;
63983   }
63984   arg2 = *argp2;
63985   {
63986     try {
63987       (arg1)->SetFocus(arg2);
63988     } catch (std::out_of_range& e) {
63989       {
63990         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
63991       };
63992     } catch (std::exception& e) {
63993       {
63994         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
63995       };
63996     } catch (Dali::DaliException e) {
63997       {
63998         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
63999       };
64000     } catch (...) {
64001       {
64002         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64003       };
64004     }
64005   }
64006
64007 }
64008
64009
64010 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_GetCurrentFocusControl(void * jarg1) {
64011   void * jresult ;
64012   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64013   Dali::Toolkit::Control result;
64014
64015   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64016   {
64017     try {
64018       result = ((Dali::Toolkit::KeyInputFocusManager const *)arg1)->GetCurrentFocusControl();
64019     } catch (std::out_of_range& e) {
64020       {
64021         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64022       };
64023     } catch (std::exception& e) {
64024       {
64025         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64026       };
64027     } catch (Dali::DaliException e) {
64028       {
64029         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64030       };
64031     } catch (...) {
64032       {
64033         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64034       };
64035     }
64036   }
64037
64038   jresult = new Dali::Toolkit::Control((const Dali::Toolkit::Control &)result);
64039   return jresult;
64040 }
64041
64042
64043 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_RemoveFocus(void * jarg1, void * jarg2) {
64044   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64045   Dali::Toolkit::Control arg2 ;
64046   Dali::Toolkit::Control *argp2 ;
64047
64048   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64049   argp2 = (Dali::Toolkit::Control *)jarg2;
64050   if (!argp2) {
64051     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
64052     return ;
64053   }
64054   arg2 = *argp2;
64055   {
64056     try {
64057       (arg1)->RemoveFocus(arg2);
64058     } catch (std::out_of_range& e) {
64059       {
64060         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64061       };
64062     } catch (std::exception& e) {
64063       {
64064         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64065       };
64066     } catch (Dali::DaliException e) {
64067       {
64068         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64069       };
64070     } catch (...) {
64071       {
64072         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64073       };
64074     }
64075   }
64076
64077 }
64078
64079
64080 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_KeyInputFocusChangedSignal(void * jarg1) {
64081   void * jresult ;
64082   Dali::Toolkit::KeyInputFocusManager *arg1 = (Dali::Toolkit::KeyInputFocusManager *) 0 ;
64083   Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *result = 0 ;
64084
64085   arg1 = (Dali::Toolkit::KeyInputFocusManager *)jarg1;
64086   {
64087     try {
64088       result = (Dali::Toolkit::KeyInputFocusManager::KeyInputFocusChangedSignalType *) &(arg1)->KeyInputFocusChangedSignal();
64089     } catch (std::out_of_range& e) {
64090       {
64091         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64092       };
64093     } catch (std::exception& e) {
64094       {
64095         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64096       };
64097     } catch (Dali::DaliException e) {
64098       {
64099         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64100       };
64101     } catch (...) {
64102       {
64103         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64104       };
64105     }
64106   }
64107
64108   jresult = (void *)result;
64109   return jresult;
64110 }
64111
64112
64113 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_0() {
64114   void * jresult ;
64115   Dali::Toolkit::Alignment::Padding *result = 0 ;
64116
64117   {
64118     try {
64119       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding();
64120     } catch (std::out_of_range& e) {
64121       {
64122         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64123       };
64124     } catch (std::exception& e) {
64125       {
64126         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64127       };
64128     } catch (Dali::DaliException e) {
64129       {
64130         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64131       };
64132     } catch (...) {
64133       {
64134         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64135       };
64136     }
64137   }
64138
64139   jresult = (void *)result;
64140   return jresult;
64141 }
64142
64143
64144 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment_Padding__SWIG_1(float jarg1, float jarg2, float jarg3, float jarg4) {
64145   void * jresult ;
64146   float arg1 ;
64147   float arg2 ;
64148   float arg3 ;
64149   float arg4 ;
64150   Dali::Toolkit::Alignment::Padding *result = 0 ;
64151
64152   arg1 = (float)jarg1;
64153   arg2 = (float)jarg2;
64154   arg3 = (float)jarg3;
64155   arg4 = (float)jarg4;
64156   {
64157     try {
64158       result = (Dali::Toolkit::Alignment::Padding *)new Dali::Toolkit::Alignment::Padding(arg1,arg2,arg3,arg4);
64159     } catch (std::out_of_range& e) {
64160       {
64161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64162       };
64163     } catch (std::exception& e) {
64164       {
64165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64166       };
64167     } catch (Dali::DaliException e) {
64168       {
64169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64170       };
64171     } catch (...) {
64172       {
64173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64174       };
64175     }
64176   }
64177
64178   jresult = (void *)result;
64179   return jresult;
64180 }
64181
64182
64183 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_set(void * jarg1, float jarg2) {
64184   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64185   float arg2 ;
64186
64187   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64188   arg2 = (float)jarg2;
64189   if (arg1) (arg1)->left = arg2;
64190 }
64191
64192
64193 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_left_get(void * jarg1) {
64194   float jresult ;
64195   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64196   float result;
64197
64198   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64199   result = (float) ((arg1)->left);
64200   jresult = result;
64201   return jresult;
64202 }
64203
64204
64205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_set(void * jarg1, float jarg2) {
64206   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64207   float arg2 ;
64208
64209   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64210   arg2 = (float)jarg2;
64211   if (arg1) (arg1)->right = arg2;
64212 }
64213
64214
64215 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_right_get(void * jarg1) {
64216   float jresult ;
64217   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64218   float result;
64219
64220   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64221   result = (float) ((arg1)->right);
64222   jresult = result;
64223   return jresult;
64224 }
64225
64226
64227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_set(void * jarg1, float jarg2) {
64228   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64229   float arg2 ;
64230
64231   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64232   arg2 = (float)jarg2;
64233   if (arg1) (arg1)->top = arg2;
64234 }
64235
64236
64237 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_top_get(void * jarg1) {
64238   float jresult ;
64239   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64240   float result;
64241
64242   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64243   result = (float) ((arg1)->top);
64244   jresult = result;
64245   return jresult;
64246 }
64247
64248
64249 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_set(void * jarg1, float jarg2) {
64250   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64251   float arg2 ;
64252
64253   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64254   arg2 = (float)jarg2;
64255   if (arg1) (arg1)->bottom = arg2;
64256 }
64257
64258
64259 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Alignment_Padding_bottom_get(void * jarg1) {
64260   float jresult ;
64261   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64262   float result;
64263
64264   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64265   result = (float) ((arg1)->bottom);
64266   jresult = result;
64267   return jresult;
64268 }
64269
64270
64271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment_Padding(void * jarg1) {
64272   Dali::Toolkit::Alignment::Padding *arg1 = (Dali::Toolkit::Alignment::Padding *) 0 ;
64273
64274   arg1 = (Dali::Toolkit::Alignment::Padding *)jarg1;
64275   {
64276     try {
64277       delete arg1;
64278     } catch (std::out_of_range& e) {
64279       {
64280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64281       };
64282     } catch (std::exception& e) {
64283       {
64284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64285       };
64286     } catch (Dali::DaliException e) {
64287       {
64288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64289       };
64290     } catch (...) {
64291       {
64292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64293       };
64294     }
64295   }
64296
64297 }
64298
64299
64300 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_0() {
64301   void * jresult ;
64302   Dali::Toolkit::Alignment *result = 0 ;
64303
64304   {
64305     try {
64306       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment();
64307     } catch (std::out_of_range& e) {
64308       {
64309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64310       };
64311     } catch (std::exception& e) {
64312       {
64313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64314       };
64315     } catch (Dali::DaliException e) {
64316       {
64317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64318       };
64319     } catch (...) {
64320       {
64321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64322       };
64323     }
64324   }
64325
64326   jresult = (void *)result;
64327   return jresult;
64328 }
64329
64330
64331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_0(int jarg1, int jarg2) {
64332   void * jresult ;
64333   Dali::Toolkit::Alignment::Type arg1 ;
64334   Dali::Toolkit::Alignment::Type arg2 ;
64335   Dali::Toolkit::Alignment result;
64336
64337   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64338   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64339   {
64340     try {
64341       result = Dali::Toolkit::Alignment::New(arg1,arg2);
64342     } catch (std::out_of_range& e) {
64343       {
64344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64345       };
64346     } catch (std::exception& e) {
64347       {
64348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64349       };
64350     } catch (Dali::DaliException e) {
64351       {
64352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64353       };
64354     } catch (...) {
64355       {
64356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64357       };
64358     }
64359   }
64360
64361   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64362   return jresult;
64363 }
64364
64365
64366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_1(int jarg1) {
64367   void * jresult ;
64368   Dali::Toolkit::Alignment::Type arg1 ;
64369   Dali::Toolkit::Alignment result;
64370
64371   arg1 = (Dali::Toolkit::Alignment::Type)jarg1;
64372   {
64373     try {
64374       result = Dali::Toolkit::Alignment::New(arg1);
64375     } catch (std::out_of_range& e) {
64376       {
64377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64378       };
64379     } catch (std::exception& e) {
64380       {
64381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64382       };
64383     } catch (Dali::DaliException e) {
64384       {
64385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64386       };
64387     } catch (...) {
64388       {
64389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64390       };
64391     }
64392   }
64393
64394   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64395   return jresult;
64396 }
64397
64398
64399 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_New__SWIG_2() {
64400   void * jresult ;
64401   Dali::Toolkit::Alignment result;
64402
64403   {
64404     try {
64405       result = Dali::Toolkit::Alignment::New();
64406     } catch (std::out_of_range& e) {
64407       {
64408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64409       };
64410     } catch (std::exception& e) {
64411       {
64412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64413       };
64414     } catch (Dali::DaliException e) {
64415       {
64416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64417       };
64418     } catch (...) {
64419       {
64420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64421       };
64422     }
64423   }
64424
64425   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64426   return jresult;
64427 }
64428
64429
64430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Alignment__SWIG_1(void * jarg1) {
64431   void * jresult ;
64432   Dali::Toolkit::Alignment *arg1 = 0 ;
64433   Dali::Toolkit::Alignment *result = 0 ;
64434
64435   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64436   if (!arg1) {
64437     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64438     return 0;
64439   }
64440   {
64441     try {
64442       result = (Dali::Toolkit::Alignment *)new Dali::Toolkit::Alignment((Dali::Toolkit::Alignment const &)*arg1);
64443     } catch (std::out_of_range& e) {
64444       {
64445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64446       };
64447     } catch (std::exception& e) {
64448       {
64449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64450       };
64451     } catch (Dali::DaliException e) {
64452       {
64453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64454       };
64455     } catch (...) {
64456       {
64457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64458       };
64459     }
64460   }
64461
64462   jresult = (void *)result;
64463   return jresult;
64464 }
64465
64466
64467 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Alignment(void * jarg1) {
64468   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64469
64470   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64471   {
64472     try {
64473       delete arg1;
64474     } catch (std::out_of_range& e) {
64475       {
64476         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64477       };
64478     } catch (std::exception& e) {
64479       {
64480         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64481       };
64482     } catch (Dali::DaliException e) {
64483       {
64484         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64485       };
64486     } catch (...) {
64487       {
64488         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64489       };
64490     }
64491   }
64492
64493 }
64494
64495
64496 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_DownCast(void * jarg1) {
64497   void * jresult ;
64498   Dali::BaseHandle arg1 ;
64499   Dali::BaseHandle *argp1 ;
64500   Dali::Toolkit::Alignment result;
64501
64502   argp1 = (Dali::BaseHandle *)jarg1;
64503   if (!argp1) {
64504     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
64505     return 0;
64506   }
64507   arg1 = *argp1;
64508   {
64509     try {
64510       result = Dali::Toolkit::Alignment::DownCast(arg1);
64511     } catch (std::out_of_range& e) {
64512       {
64513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64514       };
64515     } catch (std::exception& e) {
64516       {
64517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64518       };
64519     } catch (Dali::DaliException e) {
64520       {
64521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64522       };
64523     } catch (...) {
64524       {
64525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64526       };
64527     }
64528   }
64529
64530   jresult = new Dali::Toolkit::Alignment((const Dali::Toolkit::Alignment &)result);
64531   return jresult;
64532 }
64533
64534
64535 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetAlignmentType(void * jarg1, int jarg2) {
64536   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64537   Dali::Toolkit::Alignment::Type arg2 ;
64538
64539   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64540   arg2 = (Dali::Toolkit::Alignment::Type)jarg2;
64541   {
64542     try {
64543       (arg1)->SetAlignmentType(arg2);
64544     } catch (std::out_of_range& e) {
64545       {
64546         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64547       };
64548     } catch (std::exception& e) {
64549       {
64550         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64551       };
64552     } catch (Dali::DaliException e) {
64553       {
64554         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64555       };
64556     } catch (...) {
64557       {
64558         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64559       };
64560     }
64561   }
64562
64563 }
64564
64565
64566 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetAlignmentType(void * jarg1) {
64567   int jresult ;
64568   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64569   Dali::Toolkit::Alignment::Type result;
64570
64571   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64572   {
64573     try {
64574       result = (Dali::Toolkit::Alignment::Type)((Dali::Toolkit::Alignment const *)arg1)->GetAlignmentType();
64575     } catch (std::out_of_range& e) {
64576       {
64577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64578       };
64579     } catch (std::exception& e) {
64580       {
64581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64582       };
64583     } catch (Dali::DaliException e) {
64584       {
64585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64586       };
64587     } catch (...) {
64588       {
64589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64590       };
64591     }
64592   }
64593
64594   jresult = (int)result;
64595   return jresult;
64596 }
64597
64598
64599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetScaling(void * jarg1, int jarg2) {
64600   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64601   Dali::Toolkit::Alignment::Scaling arg2 ;
64602
64603   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64604   arg2 = (Dali::Toolkit::Alignment::Scaling)jarg2;
64605   {
64606     try {
64607       (arg1)->SetScaling(arg2);
64608     } catch (std::out_of_range& e) {
64609       {
64610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64611       };
64612     } catch (std::exception& e) {
64613       {
64614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64615       };
64616     } catch (Dali::DaliException e) {
64617       {
64618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64619       };
64620     } catch (...) {
64621       {
64622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64623       };
64624     }
64625   }
64626
64627 }
64628
64629
64630 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Alignment_GetScaling(void * jarg1) {
64631   int jresult ;
64632   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64633   Dali::Toolkit::Alignment::Scaling result;
64634
64635   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64636   {
64637     try {
64638       result = (Dali::Toolkit::Alignment::Scaling)((Dali::Toolkit::Alignment const *)arg1)->GetScaling();
64639     } catch (std::out_of_range& e) {
64640       {
64641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64642       };
64643     } catch (std::exception& e) {
64644       {
64645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64646       };
64647     } catch (Dali::DaliException e) {
64648       {
64649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64650       };
64651     } catch (...) {
64652       {
64653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64654       };
64655     }
64656   }
64657
64658   jresult = (int)result;
64659   return jresult;
64660 }
64661
64662
64663 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Alignment_SetPadding(void * jarg1, void * jarg2) {
64664   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64665   Dali::Toolkit::Alignment::Padding *arg2 = 0 ;
64666
64667   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64668   arg2 = (Dali::Toolkit::Alignment::Padding *)jarg2;
64669   if (!arg2) {
64670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment::Padding const & type is null", 0);
64671     return ;
64672   }
64673   {
64674     try {
64675       (arg1)->SetPadding((Dali::Toolkit::Alignment::Padding const &)*arg2);
64676     } catch (std::out_of_range& e) {
64677       {
64678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64679       };
64680     } catch (std::exception& e) {
64681       {
64682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64683       };
64684     } catch (Dali::DaliException e) {
64685       {
64686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64687       };
64688     } catch (...) {
64689       {
64690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64691       };
64692     }
64693   }
64694
64695 }
64696
64697
64698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_GetPadding(void * jarg1) {
64699   void * jresult ;
64700   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64701   Dali::Toolkit::Alignment::Padding *result = 0 ;
64702
64703   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64704   {
64705     try {
64706       result = (Dali::Toolkit::Alignment::Padding *) &((Dali::Toolkit::Alignment const *)arg1)->GetPadding();
64707     } catch (std::out_of_range& e) {
64708       {
64709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64710       };
64711     } catch (std::exception& e) {
64712       {
64713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64714       };
64715     } catch (Dali::DaliException e) {
64716       {
64717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64718       };
64719     } catch (...) {
64720       {
64721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64722       };
64723     }
64724   }
64725
64726   jresult = (void *)result;
64727   return jresult;
64728 }
64729
64730
64731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Alignment_Assign(void * jarg1, void * jarg2) {
64732   void * jresult ;
64733   Dali::Toolkit::Alignment *arg1 = (Dali::Toolkit::Alignment *) 0 ;
64734   Dali::Toolkit::Alignment *arg2 = 0 ;
64735   Dali::Toolkit::Alignment *result = 0 ;
64736
64737   arg1 = (Dali::Toolkit::Alignment *)jarg1;
64738   arg2 = (Dali::Toolkit::Alignment *)jarg2;
64739   if (!arg2) {
64740     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Alignment const & type is null", 0);
64741     return 0;
64742   }
64743   {
64744     try {
64745       result = (Dali::Toolkit::Alignment *) &(arg1)->operator =((Dali::Toolkit::Alignment const &)*arg2);
64746     } catch (std::out_of_range& e) {
64747       {
64748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64749       };
64750     } catch (std::exception& e) {
64751       {
64752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64753       };
64754     } catch (Dali::DaliException e) {
64755       {
64756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64757       };
64758     } catch (...) {
64759       {
64760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64761       };
64762     }
64763   }
64764
64765   jresult = (void *)result;
64766   return jresult;
64767 }
64768
64769
64770 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_DISABLED_get() {
64771   int jresult ;
64772   int result;
64773
64774   result = (int)Dali::Toolkit::Button::Property::DISABLED;
64775   jresult = (int)result;
64776   return jresult;
64777 }
64778
64779
64780 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_AUTO_REPEATING_get() {
64781   int jresult ;
64782   int result;
64783
64784   result = (int)Dali::Toolkit::Button::Property::AUTO_REPEATING;
64785   jresult = (int)result;
64786   return jresult;
64787 }
64788
64789
64790 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_INITIAL_AUTO_REPEATING_DELAY_get() {
64791   int jresult ;
64792   int result;
64793
64794   result = (int)Dali::Toolkit::Button::Property::INITIAL_AUTO_REPEATING_DELAY;
64795   jresult = (int)result;
64796   return jresult;
64797 }
64798
64799
64800 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_NEXT_AUTO_REPEATING_DELAY_get() {
64801   int jresult ;
64802   int result;
64803
64804   result = (int)Dali::Toolkit::Button::Property::NEXT_AUTO_REPEATING_DELAY;
64805   jresult = (int)result;
64806   return jresult;
64807 }
64808
64809
64810 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_TOGGLABLE_get() {
64811   int jresult ;
64812   int result;
64813
64814   result = (int)Dali::Toolkit::Button::Property::TOGGLABLE;
64815   jresult = (int)result;
64816   return jresult;
64817 }
64818
64819
64820 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_SELECTED_get() {
64821   int jresult ;
64822   int result;
64823
64824   result = (int)Dali::Toolkit::Button::Property::SELECTED;
64825   jresult = (int)result;
64826   return jresult;
64827 }
64828
64829 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Button_Property_LABEL_get() {
64830   int jresult ;
64831   int result;
64832
64833   result = (int)Dali::Toolkit::Button::Property::LABEL;
64834   jresult = (int)result;
64835   return jresult;
64836 }
64837
64838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button_Property() {
64839   void * jresult ;
64840   Dali::Toolkit::Button::Property *result = 0 ;
64841
64842   {
64843     try {
64844       result = (Dali::Toolkit::Button::Property *)new Dali::Toolkit::Button::Property();
64845     } catch (std::out_of_range& e) {
64846       {
64847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64848       };
64849     } catch (std::exception& e) {
64850       {
64851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64852       };
64853     } catch (Dali::DaliException e) {
64854       {
64855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64856       };
64857     } catch (...) {
64858       {
64859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64860       };
64861     }
64862   }
64863
64864   jresult = (void *)result;
64865   return jresult;
64866 }
64867
64868
64869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button_Property(void * jarg1) {
64870   Dali::Toolkit::Button::Property *arg1 = (Dali::Toolkit::Button::Property *) 0 ;
64871
64872   arg1 = (Dali::Toolkit::Button::Property *)jarg1;
64873   {
64874     try {
64875       delete arg1;
64876     } catch (std::out_of_range& e) {
64877       {
64878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
64879       };
64880     } catch (std::exception& e) {
64881       {
64882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
64883       };
64884     } catch (Dali::DaliException e) {
64885       {
64886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
64887       };
64888     } catch (...) {
64889       {
64890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
64891       };
64892     }
64893   }
64894
64895 }
64896
64897
64898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_0() {
64899   void * jresult ;
64900   Dali::Toolkit::Button *result = 0 ;
64901
64902   {
64903     try {
64904       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button();
64905     } catch (std::out_of_range& e) {
64906       {
64907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64908       };
64909     } catch (std::exception& e) {
64910       {
64911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64912       };
64913     } catch (Dali::DaliException e) {
64914       {
64915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64916       };
64917     } catch (...) {
64918       {
64919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64920       };
64921     }
64922   }
64923
64924   jresult = (void *)result;
64925   return jresult;
64926 }
64927
64928
64929 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Button__SWIG_1(void * jarg1) {
64930   void * jresult ;
64931   Dali::Toolkit::Button *arg1 = 0 ;
64932   Dali::Toolkit::Button *result = 0 ;
64933
64934   arg1 = (Dali::Toolkit::Button *)jarg1;
64935   if (!arg1) {
64936     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64937     return 0;
64938   }
64939   {
64940     try {
64941       result = (Dali::Toolkit::Button *)new Dali::Toolkit::Button((Dali::Toolkit::Button const &)*arg1);
64942     } catch (std::out_of_range& e) {
64943       {
64944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64945       };
64946     } catch (std::exception& e) {
64947       {
64948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64949       };
64950     } catch (Dali::DaliException e) {
64951       {
64952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64953       };
64954     } catch (...) {
64955       {
64956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64957       };
64958     }
64959   }
64960
64961   jresult = (void *)result;
64962   return jresult;
64963 }
64964
64965
64966 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_Assign(void * jarg1, void * jarg2) {
64967   void * jresult ;
64968   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
64969   Dali::Toolkit::Button *arg2 = 0 ;
64970   Dali::Toolkit::Button *result = 0 ;
64971
64972   arg1 = (Dali::Toolkit::Button *)jarg1;
64973   arg2 = (Dali::Toolkit::Button *)jarg2;
64974   if (!arg2) {
64975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Button const & type is null", 0);
64976     return 0;
64977   }
64978   {
64979     try {
64980       result = (Dali::Toolkit::Button *) &(arg1)->operator =((Dali::Toolkit::Button const &)*arg2);
64981     } catch (std::out_of_range& e) {
64982       {
64983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
64984       };
64985     } catch (std::exception& e) {
64986       {
64987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
64988       };
64989     } catch (Dali::DaliException e) {
64990       {
64991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
64992       };
64993     } catch (...) {
64994       {
64995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
64996       };
64997     }
64998   }
64999
65000   jresult = (void *)result;
65001   return jresult;
65002 }
65003
65004
65005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_DownCast(void * jarg1) {
65006   void * jresult ;
65007   Dali::BaseHandle arg1 ;
65008   Dali::BaseHandle *argp1 ;
65009   Dali::Toolkit::Button result;
65010
65011   argp1 = (Dali::BaseHandle *)jarg1;
65012   if (!argp1) {
65013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65014     return 0;
65015   }
65016   arg1 = *argp1;
65017   {
65018     try {
65019       result = Dali::Toolkit::Button::DownCast(arg1);
65020     } catch (std::out_of_range& e) {
65021       {
65022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65023       };
65024     } catch (std::exception& e) {
65025       {
65026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65027       };
65028     } catch (Dali::DaliException e) {
65029       {
65030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65031       };
65032     } catch (...) {
65033       {
65034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65035       };
65036     }
65037   }
65038
65039   jresult = new Dali::Toolkit::Button((const Dali::Toolkit::Button &)result);
65040   return jresult;
65041 }
65042
65043
65044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Button(void * jarg1) {
65045   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65046
65047   arg1 = (Dali::Toolkit::Button *)jarg1;
65048   {
65049     try {
65050       delete arg1;
65051     } catch (std::out_of_range& e) {
65052       {
65053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65054       };
65055     } catch (std::exception& e) {
65056       {
65057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65058       };
65059     } catch (Dali::DaliException e) {
65060       {
65061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65062       };
65063     } catch (...) {
65064       {
65065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65066       };
65067     }
65068   }
65069
65070 }
65071
65072 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_PressedSignal(void * jarg1) {
65073   void * jresult ;
65074   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65075   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65076
65077   arg1 = (Dali::Toolkit::Button *)jarg1;
65078   {
65079     try {
65080       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->PressedSignal();
65081     } catch (std::out_of_range& e) {
65082       {
65083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65084       };
65085     } catch (std::exception& e) {
65086       {
65087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65088       };
65089     } catch (Dali::DaliException e) {
65090       {
65091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65092       };
65093     } catch (...) {
65094       {
65095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65096       };
65097     }
65098   }
65099
65100   jresult = (void *)result;
65101   return jresult;
65102 }
65103
65104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ReleasedSignal(void * jarg1) {
65105   void * jresult ;
65106   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65107   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65108
65109   arg1 = (Dali::Toolkit::Button *)jarg1;
65110   {
65111     try {
65112       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ReleasedSignal();
65113     } catch (std::out_of_range& e) {
65114       {
65115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65116       };
65117     } catch (std::exception& e) {
65118       {
65119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65120       };
65121     } catch (Dali::DaliException e) {
65122       {
65123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65124       };
65125     } catch (...) {
65126       {
65127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65128       };
65129     }
65130   }
65131
65132   jresult = (void *)result;
65133   return jresult;
65134 }
65135
65136
65137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_ClickedSignal(void * jarg1) {
65138   void * jresult ;
65139   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65140   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65141
65142   arg1 = (Dali::Toolkit::Button *)jarg1;
65143   {
65144     try {
65145       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->ClickedSignal();
65146     } catch (std::out_of_range& e) {
65147       {
65148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65149       };
65150     } catch (std::exception& e) {
65151       {
65152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65153       };
65154     } catch (Dali::DaliException e) {
65155       {
65156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65157       };
65158     } catch (...) {
65159       {
65160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65161       };
65162     }
65163   }
65164
65165   jresult = (void *)result;
65166   return jresult;
65167 }
65168
65169
65170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Button_StateChangedSignal(void * jarg1) {
65171   void * jresult ;
65172   Dali::Toolkit::Button *arg1 = (Dali::Toolkit::Button *) 0 ;
65173   Dali::Toolkit::Button::ButtonSignalType *result = 0 ;
65174
65175   arg1 = (Dali::Toolkit::Button *)jarg1;
65176   {
65177     try {
65178       result = (Dali::Toolkit::Button::ButtonSignalType *) &(arg1)->StateChangedSignal();
65179     } catch (std::out_of_range& e) {
65180       {
65181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65182       };
65183     } catch (std::exception& e) {
65184       {
65185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65186       };
65187     } catch (Dali::DaliException e) {
65188       {
65189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65190       };
65191     } catch (...) {
65192       {
65193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65194       };
65195     }
65196   }
65197
65198   jresult = (void *)result;
65199   return jresult;
65200 }
65201
65202
65203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_0() {
65204   void * jresult ;
65205   Dali::Toolkit::CheckBoxButton *result = 0 ;
65206
65207   {
65208     try {
65209       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton();
65210     } catch (std::out_of_range& e) {
65211       {
65212         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65213       };
65214     } catch (std::exception& e) {
65215       {
65216         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65217       };
65218     } catch (Dali::DaliException e) {
65219       {
65220         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65221       };
65222     } catch (...) {
65223       {
65224         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65225       };
65226     }
65227   }
65228
65229   jresult = (void *)result;
65230   return jresult;
65231 }
65232
65233
65234 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CheckBoxButton__SWIG_1(void * jarg1) {
65235   void * jresult ;
65236   Dali::Toolkit::CheckBoxButton *arg1 = 0 ;
65237   Dali::Toolkit::CheckBoxButton *result = 0 ;
65238
65239   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65240   if (!arg1) {
65241     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65242     return 0;
65243   }
65244   {
65245     try {
65246       result = (Dali::Toolkit::CheckBoxButton *)new Dali::Toolkit::CheckBoxButton((Dali::Toolkit::CheckBoxButton const &)*arg1);
65247     } catch (std::out_of_range& e) {
65248       {
65249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65250       };
65251     } catch (std::exception& e) {
65252       {
65253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65254       };
65255     } catch (Dali::DaliException e) {
65256       {
65257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65258       };
65259     } catch (...) {
65260       {
65261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65262       };
65263     }
65264   }
65265
65266   jresult = (void *)result;
65267   return jresult;
65268 }
65269
65270
65271 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_Assign(void * jarg1, void * jarg2) {
65272   void * jresult ;
65273   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65274   Dali::Toolkit::CheckBoxButton *arg2 = 0 ;
65275   Dali::Toolkit::CheckBoxButton *result = 0 ;
65276
65277   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65278   arg2 = (Dali::Toolkit::CheckBoxButton *)jarg2;
65279   if (!arg2) {
65280     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::CheckBoxButton const & type is null", 0);
65281     return 0;
65282   }
65283   {
65284     try {
65285       result = (Dali::Toolkit::CheckBoxButton *) &(arg1)->operator =((Dali::Toolkit::CheckBoxButton const &)*arg2);
65286     } catch (std::out_of_range& e) {
65287       {
65288         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65289       };
65290     } catch (std::exception& e) {
65291       {
65292         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65293       };
65294     } catch (Dali::DaliException e) {
65295       {
65296         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65297       };
65298     } catch (...) {
65299       {
65300         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65301       };
65302     }
65303   }
65304
65305   jresult = (void *)result;
65306   return jresult;
65307 }
65308
65309
65310 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CheckBoxButton(void * jarg1) {
65311   Dali::Toolkit::CheckBoxButton *arg1 = (Dali::Toolkit::CheckBoxButton *) 0 ;
65312
65313   arg1 = (Dali::Toolkit::CheckBoxButton *)jarg1;
65314   {
65315     try {
65316       delete arg1;
65317     } catch (std::out_of_range& e) {
65318       {
65319         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65320       };
65321     } catch (std::exception& e) {
65322       {
65323         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65324       };
65325     } catch (Dali::DaliException e) {
65326       {
65327         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65328       };
65329     } catch (...) {
65330       {
65331         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65332       };
65333     }
65334   }
65335
65336 }
65337
65338
65339 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_New() {
65340   void * jresult ;
65341   Dali::Toolkit::CheckBoxButton result;
65342
65343   {
65344     try {
65345       result = Dali::Toolkit::CheckBoxButton::New();
65346     } catch (std::out_of_range& e) {
65347       {
65348         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65349       };
65350     } catch (std::exception& e) {
65351       {
65352         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65353       };
65354     } catch (Dali::DaliException e) {
65355       {
65356         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65357       };
65358     } catch (...) {
65359       {
65360         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65361       };
65362     }
65363   }
65364
65365   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65366   return jresult;
65367 }
65368
65369
65370 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CheckBoxButton_DownCast(void * jarg1) {
65371   void * jresult ;
65372   Dali::BaseHandle arg1 ;
65373   Dali::BaseHandle *argp1 ;
65374   Dali::Toolkit::CheckBoxButton result;
65375
65376   argp1 = (Dali::BaseHandle *)jarg1;
65377   if (!argp1) {
65378     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65379     return 0;
65380   }
65381   arg1 = *argp1;
65382   {
65383     try {
65384       result = Dali::Toolkit::CheckBoxButton::DownCast(arg1);
65385     } catch (std::out_of_range& e) {
65386       {
65387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65388       };
65389     } catch (std::exception& e) {
65390       {
65391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65392       };
65393     } catch (Dali::DaliException e) {
65394       {
65395         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65396       };
65397     } catch (...) {
65398       {
65399         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65400       };
65401     }
65402   }
65403
65404   jresult = new Dali::Toolkit::CheckBoxButton((const Dali::Toolkit::CheckBoxButton &)result);
65405   return jresult;
65406 }
65407
65408
65409 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_LABEL_PADDING_get() {
65410   int jresult ;
65411   int result;
65412
65413   result = (int)Dali::Toolkit::PushButton::Property::LABEL_PADDING;
65414   jresult = (int)result;
65415   return jresult;
65416 }
65417
65418
65419 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PushButton_Property_ICON_PADDING_get() {
65420   int jresult ;
65421   int result;
65422
65423   result = (int)Dali::Toolkit::PushButton::Property::ICON_PADDING;
65424   jresult = (int)result;
65425   return jresult;
65426 }
65427
65428
65429 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton_Property() {
65430   void * jresult ;
65431   Dali::Toolkit::PushButton::Property *result = 0 ;
65432
65433   {
65434     try {
65435       result = (Dali::Toolkit::PushButton::Property *)new Dali::Toolkit::PushButton::Property();
65436     } catch (std::out_of_range& e) {
65437       {
65438         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65439       };
65440     } catch (std::exception& e) {
65441       {
65442         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65443       };
65444     } catch (Dali::DaliException e) {
65445       {
65446         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65447       };
65448     } catch (...) {
65449       {
65450         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65451       };
65452     }
65453   }
65454
65455   jresult = (void *)result;
65456   return jresult;
65457 }
65458
65459
65460 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton_Property(void * jarg1) {
65461   Dali::Toolkit::PushButton::Property *arg1 = (Dali::Toolkit::PushButton::Property *) 0 ;
65462
65463   arg1 = (Dali::Toolkit::PushButton::Property *)jarg1;
65464   {
65465     try {
65466       delete arg1;
65467     } catch (std::out_of_range& e) {
65468       {
65469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65470       };
65471     } catch (std::exception& e) {
65472       {
65473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65474       };
65475     } catch (Dali::DaliException e) {
65476       {
65477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65478       };
65479     } catch (...) {
65480       {
65481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65482       };
65483     }
65484   }
65485
65486 }
65487
65488
65489 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_0() {
65490   void * jresult ;
65491   Dali::Toolkit::PushButton *result = 0 ;
65492
65493   {
65494     try {
65495       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton();
65496     } catch (std::out_of_range& e) {
65497       {
65498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65499       };
65500     } catch (std::exception& e) {
65501       {
65502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65503       };
65504     } catch (Dali::DaliException e) {
65505       {
65506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65507       };
65508     } catch (...) {
65509       {
65510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65511       };
65512     }
65513   }
65514
65515   jresult = (void *)result;
65516   return jresult;
65517 }
65518
65519
65520 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PushButton__SWIG_1(void * jarg1) {
65521   void * jresult ;
65522   Dali::Toolkit::PushButton *arg1 = 0 ;
65523   Dali::Toolkit::PushButton *result = 0 ;
65524
65525   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65526   if (!arg1) {
65527     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65528     return 0;
65529   }
65530   {
65531     try {
65532       result = (Dali::Toolkit::PushButton *)new Dali::Toolkit::PushButton((Dali::Toolkit::PushButton const &)*arg1);
65533     } catch (std::out_of_range& e) {
65534       {
65535         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65536       };
65537     } catch (std::exception& e) {
65538       {
65539         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65540       };
65541     } catch (Dali::DaliException e) {
65542       {
65543         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65544       };
65545     } catch (...) {
65546       {
65547         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65548       };
65549     }
65550   }
65551
65552   jresult = (void *)result;
65553   return jresult;
65554 }
65555
65556
65557 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_Assign(void * jarg1, void * jarg2) {
65558   void * jresult ;
65559   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65560   Dali::Toolkit::PushButton *arg2 = 0 ;
65561   Dali::Toolkit::PushButton *result = 0 ;
65562
65563   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65564   arg2 = (Dali::Toolkit::PushButton *)jarg2;
65565   if (!arg2) {
65566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PushButton const & type is null", 0);
65567     return 0;
65568   }
65569   {
65570     try {
65571       result = (Dali::Toolkit::PushButton *) &(arg1)->operator =((Dali::Toolkit::PushButton const &)*arg2);
65572     } catch (std::out_of_range& e) {
65573       {
65574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65575       };
65576     } catch (std::exception& e) {
65577       {
65578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65579       };
65580     } catch (Dali::DaliException e) {
65581       {
65582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65583       };
65584     } catch (...) {
65585       {
65586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65587       };
65588     }
65589   }
65590
65591   jresult = (void *)result;
65592   return jresult;
65593 }
65594
65595
65596 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PushButton(void * jarg1) {
65597   Dali::Toolkit::PushButton *arg1 = (Dali::Toolkit::PushButton *) 0 ;
65598
65599   arg1 = (Dali::Toolkit::PushButton *)jarg1;
65600   {
65601     try {
65602       delete arg1;
65603     } catch (std::out_of_range& e) {
65604       {
65605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65606       };
65607     } catch (std::exception& e) {
65608       {
65609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65610       };
65611     } catch (Dali::DaliException e) {
65612       {
65613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65614       };
65615     } catch (...) {
65616       {
65617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65618       };
65619     }
65620   }
65621
65622 }
65623
65624
65625 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_New() {
65626   void * jresult ;
65627   Dali::Toolkit::PushButton result;
65628
65629   {
65630     try {
65631       result = Dali::Toolkit::PushButton::New();
65632     } catch (std::out_of_range& e) {
65633       {
65634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65635       };
65636     } catch (std::exception& e) {
65637       {
65638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65639       };
65640     } catch (Dali::DaliException e) {
65641       {
65642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65643       };
65644     } catch (...) {
65645       {
65646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65647       };
65648     }
65649   }
65650
65651   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65652   return jresult;
65653 }
65654
65655
65656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PushButton_DownCast(void * jarg1) {
65657   void * jresult ;
65658   Dali::BaseHandle arg1 ;
65659   Dali::BaseHandle *argp1 ;
65660   Dali::Toolkit::PushButton result;
65661
65662   argp1 = (Dali::BaseHandle *)jarg1;
65663   if (!argp1) {
65664     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65665     return 0;
65666   }
65667   arg1 = *argp1;
65668   {
65669     try {
65670       result = Dali::Toolkit::PushButton::DownCast(arg1);
65671     } catch (std::out_of_range& e) {
65672       {
65673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65674       };
65675     } catch (std::exception& e) {
65676       {
65677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65678       };
65679     } catch (Dali::DaliException e) {
65680       {
65681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65682       };
65683     } catch (...) {
65684       {
65685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65686       };
65687     }
65688   }
65689
65690   jresult = new Dali::Toolkit::PushButton((const Dali::Toolkit::PushButton &)result);
65691   return jresult;
65692 }
65693
65694 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_0() {
65695   void * jresult ;
65696   Dali::Toolkit::RadioButton *result = 0 ;
65697
65698   {
65699     try {
65700       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton();
65701     } catch (std::out_of_range& e) {
65702       {
65703         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65704       };
65705     } catch (std::exception& e) {
65706       {
65707         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65708       };
65709     } catch (Dali::DaliException e) {
65710       {
65711         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65712       };
65713     } catch (...) {
65714       {
65715         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65716       };
65717     }
65718   }
65719
65720   jresult = (void *)result;
65721   return jresult;
65722 }
65723
65724
65725 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RadioButton__SWIG_1(void * jarg1) {
65726   void * jresult ;
65727   Dali::Toolkit::RadioButton *arg1 = 0 ;
65728   Dali::Toolkit::RadioButton *result = 0 ;
65729
65730   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65731   if (!arg1) {
65732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65733     return 0;
65734   }
65735   {
65736     try {
65737       result = (Dali::Toolkit::RadioButton *)new Dali::Toolkit::RadioButton((Dali::Toolkit::RadioButton const &)*arg1);
65738     } catch (std::out_of_range& e) {
65739       {
65740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65741       };
65742     } catch (std::exception& e) {
65743       {
65744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65745       };
65746     } catch (Dali::DaliException e) {
65747       {
65748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65749       };
65750     } catch (...) {
65751       {
65752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65753       };
65754     }
65755   }
65756
65757   jresult = (void *)result;
65758   return jresult;
65759 }
65760
65761
65762 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_Assign(void * jarg1, void * jarg2) {
65763   void * jresult ;
65764   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65765   Dali::Toolkit::RadioButton *arg2 = 0 ;
65766   Dali::Toolkit::RadioButton *result = 0 ;
65767
65768   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65769   arg2 = (Dali::Toolkit::RadioButton *)jarg2;
65770   if (!arg2) {
65771     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::RadioButton const & type is null", 0);
65772     return 0;
65773   }
65774   {
65775     try {
65776       result = (Dali::Toolkit::RadioButton *) &(arg1)->operator =((Dali::Toolkit::RadioButton const &)*arg2);
65777     } catch (std::out_of_range& e) {
65778       {
65779         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65780       };
65781     } catch (std::exception& e) {
65782       {
65783         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65784       };
65785     } catch (Dali::DaliException e) {
65786       {
65787         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65788       };
65789     } catch (...) {
65790       {
65791         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65792       };
65793     }
65794   }
65795
65796   jresult = (void *)result;
65797   return jresult;
65798 }
65799
65800
65801 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RadioButton(void * jarg1) {
65802   Dali::Toolkit::RadioButton *arg1 = (Dali::Toolkit::RadioButton *) 0 ;
65803
65804   arg1 = (Dali::Toolkit::RadioButton *)jarg1;
65805   {
65806     try {
65807       delete arg1;
65808     } catch (std::out_of_range& e) {
65809       {
65810         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
65811       };
65812     } catch (std::exception& e) {
65813       {
65814         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
65815       };
65816     } catch (Dali::DaliException e) {
65817       {
65818         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
65819       };
65820     } catch (...) {
65821       {
65822         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
65823       };
65824     }
65825   }
65826
65827 }
65828
65829
65830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_0() {
65831   void * jresult ;
65832   Dali::Toolkit::RadioButton result;
65833
65834   {
65835     try {
65836       result = Dali::Toolkit::RadioButton::New();
65837     } catch (std::out_of_range& e) {
65838       {
65839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65840       };
65841     } catch (std::exception& e) {
65842       {
65843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65844       };
65845     } catch (Dali::DaliException e) {
65846       {
65847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65848       };
65849     } catch (...) {
65850       {
65851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65852       };
65853     }
65854   }
65855
65856   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65857   return jresult;
65858 }
65859
65860
65861 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_New__SWIG_1(char * jarg1) {
65862   void * jresult ;
65863   std::string *arg1 = 0 ;
65864   Dali::Toolkit::RadioButton result;
65865
65866   if (!jarg1) {
65867     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
65868     return 0;
65869   }
65870   std::string arg1_str(jarg1);
65871   arg1 = &arg1_str;
65872   {
65873     try {
65874       result = Dali::Toolkit::RadioButton::New((std::string const &)*arg1);
65875     } catch (std::out_of_range& e) {
65876       {
65877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65878       };
65879     } catch (std::exception& e) {
65880       {
65881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65882       };
65883     } catch (Dali::DaliException e) {
65884       {
65885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65886       };
65887     } catch (...) {
65888       {
65889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65890       };
65891     }
65892   }
65893
65894   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65895
65896   //argout typemap for const std::string&
65897
65898   return jresult;
65899 }
65900
65901
65902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RadioButton_DownCast(void * jarg1) {
65903   void * jresult ;
65904   Dali::BaseHandle arg1 ;
65905   Dali::BaseHandle *argp1 ;
65906   Dali::Toolkit::RadioButton result;
65907
65908   argp1 = (Dali::BaseHandle *)jarg1;
65909   if (!argp1) {
65910     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
65911     return 0;
65912   }
65913   arg1 = *argp1;
65914   {
65915     try {
65916       result = Dali::Toolkit::RadioButton::DownCast(arg1);
65917     } catch (std::out_of_range& e) {
65918       {
65919         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
65920       };
65921     } catch (std::exception& e) {
65922       {
65923         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
65924       };
65925     } catch (Dali::DaliException e) {
65926       {
65927         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
65928       };
65929     } catch (...) {
65930       {
65931         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
65932       };
65933     }
65934   }
65935
65936   jresult = new Dali::Toolkit::RadioButton((const Dali::Toolkit::RadioButton &)result);
65937   return jresult;
65938 }
65939
65940
65941 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_CONTENT_DIRECTION_get() {
65942   int jresult ;
65943   int result;
65944
65945   result = (int)Dali::Toolkit::FlexContainer::Property::CONTENT_DIRECTION;
65946   jresult = (int)result;
65947   return jresult;
65948 }
65949
65950
65951 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_DIRECTION_get() {
65952   int jresult ;
65953   int result;
65954
65955   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_DIRECTION;
65956   jresult = (int)result;
65957   return jresult;
65958 }
65959
65960
65961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_FLEX_WRAP_get() {
65962   int jresult ;
65963   int result;
65964
65965   result = (int)Dali::Toolkit::FlexContainer::Property::FLEX_WRAP;
65966   jresult = (int)result;
65967   return jresult;
65968 }
65969
65970
65971 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_JUSTIFY_CONTENT_get() {
65972   int jresult ;
65973   int result;
65974
65975   result = (int)Dali::Toolkit::FlexContainer::Property::JUSTIFY_CONTENT;
65976   jresult = (int)result;
65977   return jresult;
65978 }
65979
65980
65981 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_ITEMS_get() {
65982   int jresult ;
65983   int result;
65984
65985   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_ITEMS;
65986   jresult = (int)result;
65987   return jresult;
65988 }
65989
65990
65991 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_Property_ALIGN_CONTENT_get() {
65992   int jresult ;
65993   int result;
65994
65995   result = (int)Dali::Toolkit::FlexContainer::Property::ALIGN_CONTENT;
65996   jresult = (int)result;
65997   return jresult;
65998 }
65999
66000
66001 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_Property() {
66002   void * jresult ;
66003   Dali::Toolkit::FlexContainer::Property *result = 0 ;
66004
66005   {
66006     try {
66007       result = (Dali::Toolkit::FlexContainer::Property *)new Dali::Toolkit::FlexContainer::Property();
66008     } catch (std::out_of_range& e) {
66009       {
66010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66011       };
66012     } catch (std::exception& e) {
66013       {
66014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66015       };
66016     } catch (Dali::DaliException e) {
66017       {
66018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66019       };
66020     } catch (...) {
66021       {
66022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66023       };
66024     }
66025   }
66026
66027   jresult = (void *)result;
66028   return jresult;
66029 }
66030
66031
66032 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_Property(void * jarg1) {
66033   Dali::Toolkit::FlexContainer::Property *arg1 = (Dali::Toolkit::FlexContainer::Property *) 0 ;
66034
66035   arg1 = (Dali::Toolkit::FlexContainer::Property *)jarg1;
66036   {
66037     try {
66038       delete arg1;
66039     } catch (std::out_of_range& e) {
66040       {
66041         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66042       };
66043     } catch (std::exception& e) {
66044       {
66045         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66046       };
66047     } catch (Dali::DaliException e) {
66048       {
66049         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66050       };
66051     } catch (...) {
66052       {
66053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66054       };
66055     }
66056   }
66057
66058 }
66059
66060
66061 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_get() {
66062   int jresult ;
66063   int result;
66064
66065   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX;
66066   jresult = (int)result;
66067   return jresult;
66068 }
66069
66070
66071 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_ALIGN_SELF_get() {
66072   int jresult ;
66073   int result;
66074
66075   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::ALIGN_SELF;
66076   jresult = (int)result;
66077   return jresult;
66078 }
66079
66080
66081 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_FlexContainer_ChildProperty_FLEX_MARGIN_get() {
66082   int jresult ;
66083   int result;
66084
66085   result = (int)Dali::Toolkit::FlexContainer::ChildProperty::FLEX_MARGIN;
66086   jresult = (int)result;
66087   return jresult;
66088 }
66089
66090
66091 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer_ChildProperty() {
66092   void * jresult ;
66093   Dali::Toolkit::FlexContainer::ChildProperty *result = 0 ;
66094
66095   {
66096     try {
66097       result = (Dali::Toolkit::FlexContainer::ChildProperty *)new Dali::Toolkit::FlexContainer::ChildProperty();
66098     } catch (std::out_of_range& e) {
66099       {
66100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66101       };
66102     } catch (std::exception& e) {
66103       {
66104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66105       };
66106     } catch (Dali::DaliException e) {
66107       {
66108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66109       };
66110     } catch (...) {
66111       {
66112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66113       };
66114     }
66115   }
66116
66117   jresult = (void *)result;
66118   return jresult;
66119 }
66120
66121
66122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FlexContainer_ChildProperty(void * jarg1) {
66123   Dali::Toolkit::FlexContainer::ChildProperty *arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *) 0 ;
66124
66125   arg1 = (Dali::Toolkit::FlexContainer::ChildProperty *)jarg1;
66126   {
66127     try {
66128       delete arg1;
66129     } catch (std::out_of_range& e) {
66130       {
66131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66132       };
66133     } catch (std::exception& e) {
66134       {
66135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66136       };
66137     } catch (Dali::DaliException e) {
66138       {
66139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66140       };
66141     } catch (...) {
66142       {
66143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66144       };
66145     }
66146   }
66147
66148 }
66149
66150
66151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_0() {
66152   void * jresult ;
66153   Dali::Toolkit::FlexContainer *result = 0 ;
66154
66155   {
66156     try {
66157       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer();
66158     } catch (std::out_of_range& e) {
66159       {
66160         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66161       };
66162     } catch (std::exception& e) {
66163       {
66164         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66165       };
66166     } catch (Dali::DaliException e) {
66167       {
66168         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66169       };
66170     } catch (...) {
66171       {
66172         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66173       };
66174     }
66175   }
66176
66177   jresult = (void *)result;
66178   return jresult;
66179 }
66180
66181
66182 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FlexContainer__SWIG_1(void * jarg1) {
66183   void * jresult ;
66184   Dali::Toolkit::FlexContainer *arg1 = 0 ;
66185   Dali::Toolkit::FlexContainer *result = 0 ;
66186
66187   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66188   if (!arg1) {
66189     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66190     return 0;
66191   }
66192   {
66193     try {
66194       result = (Dali::Toolkit::FlexContainer *)new Dali::Toolkit::FlexContainer((Dali::Toolkit::FlexContainer const &)*arg1);
66195     } catch (std::out_of_range& e) {
66196       {
66197         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66198       };
66199     } catch (std::exception& e) {
66200       {
66201         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66202       };
66203     } catch (Dali::DaliException e) {
66204       {
66205         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66206       };
66207     } catch (...) {
66208       {
66209         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66210       };
66211     }
66212   }
66213
66214   jresult = (void *)result;
66215   return jresult;
66216 }
66217
66218
66219 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_Assign(void * jarg1, void * jarg2) {
66220   void * jresult ;
66221   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66222   Dali::Toolkit::FlexContainer *arg2 = 0 ;
66223   Dali::Toolkit::FlexContainer *result = 0 ;
66224
66225   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66226   arg2 = (Dali::Toolkit::FlexContainer *)jarg2;
66227   if (!arg2) {
66228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::FlexContainer const & type is null", 0);
66229     return 0;
66230   }
66231   {
66232     try {
66233       result = (Dali::Toolkit::FlexContainer *) &(arg1)->operator =((Dali::Toolkit::FlexContainer const &)*arg2);
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_delete_FlexContainer(void * jarg1) {
66259   Dali::Toolkit::FlexContainer *arg1 = (Dali::Toolkit::FlexContainer *) 0 ;
66260
66261   arg1 = (Dali::Toolkit::FlexContainer *)jarg1;
66262   {
66263     try {
66264       delete arg1;
66265     } catch (std::out_of_range& e) {
66266       {
66267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66268       };
66269     } catch (std::exception& e) {
66270       {
66271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66272       };
66273     } catch (Dali::DaliException e) {
66274       {
66275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66276       };
66277     } catch (...) {
66278       {
66279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66280       };
66281     }
66282   }
66283
66284 }
66285
66286
66287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_New() {
66288   void * jresult ;
66289   Dali::Toolkit::FlexContainer result;
66290
66291   {
66292     try {
66293       result = Dali::Toolkit::FlexContainer::New();
66294     } catch (std::out_of_range& e) {
66295       {
66296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66297       };
66298     } catch (std::exception& e) {
66299       {
66300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66301       };
66302     } catch (Dali::DaliException e) {
66303       {
66304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66305       };
66306     } catch (...) {
66307       {
66308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66309       };
66310     }
66311   }
66312
66313   jresult = new Dali::Toolkit::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66314   return jresult;
66315 }
66316
66317
66318 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_FlexContainer_DownCast(void * jarg1) {
66319   void * jresult ;
66320   Dali::BaseHandle arg1 ;
66321   Dali::BaseHandle *argp1 ;
66322   Dali::Toolkit::FlexContainer result;
66323
66324   argp1 = (Dali::BaseHandle *)jarg1;
66325   if (!argp1) {
66326     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66327     return 0;
66328   }
66329   arg1 = *argp1;
66330   {
66331     try {
66332       result = Dali::Toolkit::FlexContainer::DownCast(arg1);
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::FlexContainer((const Dali::Toolkit::FlexContainer &)result);
66353   return jresult;
66354 }
66355
66356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_IMAGE_get() {
66357   int jresult ;
66358   int result;
66359
66360   result = (int)Dali::Toolkit::ImageView::Property::IMAGE;
66361   jresult = (int)result;
66362   return jresult;
66363 }
66364
66365
66366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PRE_MULTIPLIED_ALPHA_get() {
66367   int jresult ;
66368   int result;
66369
66370   result = (int)Dali::Toolkit::ImageView::Property::PRE_MULTIPLIED_ALPHA;
66371   jresult = (int)result;
66372   return jresult;
66373 }
66374
66375
66376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ImageView_Property_PIXEL_AREA_get() {
66377   int jresult ;
66378   int result;
66379
66380   result = (int)Dali::Toolkit::ImageView::Property::PIXEL_AREA;
66381   jresult = (int)result;
66382   return jresult;
66383 }
66384
66385
66386 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView_Property() {
66387   void * jresult ;
66388   Dali::Toolkit::ImageView::Property *result = 0 ;
66389
66390   {
66391     try {
66392       result = (Dali::Toolkit::ImageView::Property *)new Dali::Toolkit::ImageView::Property();
66393     } catch (std::out_of_range& e) {
66394       {
66395         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66396       };
66397     } catch (std::exception& e) {
66398       {
66399         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66400       };
66401     } catch (Dali::DaliException e) {
66402       {
66403         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66404       };
66405     } catch (...) {
66406       {
66407         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66408       };
66409     }
66410   }
66411
66412   jresult = (void *)result;
66413   return jresult;
66414 }
66415
66416
66417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView_Property(void * jarg1) {
66418   Dali::Toolkit::ImageView::Property *arg1 = (Dali::Toolkit::ImageView::Property *) 0 ;
66419
66420   arg1 = (Dali::Toolkit::ImageView::Property *)jarg1;
66421   {
66422     try {
66423       delete arg1;
66424     } catch (std::out_of_range& e) {
66425       {
66426         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66427       };
66428     } catch (std::exception& e) {
66429       {
66430         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66431       };
66432     } catch (Dali::DaliException e) {
66433       {
66434         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66435       };
66436     } catch (...) {
66437       {
66438         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66439       };
66440     }
66441   }
66442
66443 }
66444
66445
66446 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_0() {
66447   void * jresult ;
66448   Dali::Toolkit::ImageView *result = 0 ;
66449
66450   {
66451     try {
66452       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView();
66453     } catch (std::out_of_range& e) {
66454       {
66455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66456       };
66457     } catch (std::exception& e) {
66458       {
66459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66460       };
66461     } catch (Dali::DaliException e) {
66462       {
66463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66464       };
66465     } catch (...) {
66466       {
66467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66468       };
66469     }
66470   }
66471
66472   jresult = (void *)result;
66473   return jresult;
66474 }
66475
66476
66477 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_0() {
66478   void * jresult ;
66479   Dali::Toolkit::ImageView result;
66480
66481   {
66482     try {
66483       result = Dali::Toolkit::ImageView::New();
66484     } catch (std::out_of_range& e) {
66485       {
66486         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66487       };
66488     } catch (std::exception& e) {
66489       {
66490         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66491       };
66492     } catch (Dali::DaliException e) {
66493       {
66494         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66495       };
66496     } catch (...) {
66497       {
66498         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66499       };
66500     }
66501   }
66502
66503   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66504   return jresult;
66505 }
66506
66507
66508 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_2(char * jarg1) {
66509   void * jresult ;
66510   std::string *arg1 = 0 ;
66511   Dali::Toolkit::ImageView result;
66512
66513   if (!jarg1) {
66514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66515     return 0;
66516   }
66517   std::string arg1_str(jarg1);
66518   arg1 = &arg1_str;
66519   {
66520     try {
66521       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1);
66522     } catch (std::out_of_range& e) {
66523       {
66524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66525       };
66526     } catch (std::exception& e) {
66527       {
66528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66529       };
66530     } catch (Dali::DaliException e) {
66531       {
66532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66533       };
66534     } catch (...) {
66535       {
66536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66537       };
66538     }
66539   }
66540
66541   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66542
66543   //argout typemap for const std::string&
66544
66545   return jresult;
66546 }
66547
66548
66549 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_New__SWIG_3(char * jarg1, void * jarg2) {
66550   void * jresult ;
66551   std::string *arg1 = 0 ;
66552   Dali::ImageDimensions arg2 ;
66553   Dali::ImageDimensions *argp2 ;
66554   Dali::Toolkit::ImageView result;
66555
66556   if (!jarg1) {
66557     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66558     return 0;
66559   }
66560   std::string arg1_str(jarg1);
66561   arg1 = &arg1_str;
66562   argp2 = (Dali::ImageDimensions *)jarg2;
66563   if (!argp2) {
66564     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66565     return 0;
66566   }
66567   arg2 = *argp2;
66568   {
66569     try {
66570       result = Dali::Toolkit::ImageView::New((std::string const &)*arg1,arg2);
66571     } catch (std::out_of_range& e) {
66572       {
66573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66574       };
66575     } catch (std::exception& e) {
66576       {
66577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66578       };
66579     } catch (Dali::DaliException e) {
66580       {
66581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66582       };
66583     } catch (...) {
66584       {
66585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66586       };
66587     }
66588   }
66589
66590   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66591
66592   //argout typemap for const std::string&
66593
66594   return jresult;
66595 }
66596
66597
66598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ImageView(void * jarg1) {
66599   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66600
66601   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66602   {
66603     try {
66604       delete arg1;
66605     } catch (std::out_of_range& e) {
66606       {
66607         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66608       };
66609     } catch (std::exception& e) {
66610       {
66611         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66612       };
66613     } catch (Dali::DaliException e) {
66614       {
66615         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66616       };
66617     } catch (...) {
66618       {
66619         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66620       };
66621     }
66622   }
66623
66624 }
66625
66626
66627 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ImageView__SWIG_1(void * jarg1) {
66628   void * jresult ;
66629   Dali::Toolkit::ImageView *arg1 = 0 ;
66630   Dali::Toolkit::ImageView *result = 0 ;
66631
66632   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66633   if (!arg1) {
66634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66635     return 0;
66636   }
66637   {
66638     try {
66639       result = (Dali::Toolkit::ImageView *)new Dali::Toolkit::ImageView((Dali::Toolkit::ImageView const &)*arg1);
66640     } catch (std::out_of_range& e) {
66641       {
66642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66643       };
66644     } catch (std::exception& e) {
66645       {
66646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66647       };
66648     } catch (Dali::DaliException e) {
66649       {
66650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66651       };
66652     } catch (...) {
66653       {
66654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66655       };
66656     }
66657   }
66658
66659   jresult = (void *)result;
66660   return jresult;
66661 }
66662
66663
66664 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_Assign(void * jarg1, void * jarg2) {
66665   void * jresult ;
66666   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66667   Dali::Toolkit::ImageView *arg2 = 0 ;
66668   Dali::Toolkit::ImageView *result = 0 ;
66669
66670   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66671   arg2 = (Dali::Toolkit::ImageView *)jarg2;
66672   if (!arg2) {
66673     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ImageView const & type is null", 0);
66674     return 0;
66675   }
66676   {
66677     try {
66678       result = (Dali::Toolkit::ImageView *) &(arg1)->operator =((Dali::Toolkit::ImageView const &)*arg2);
66679     } catch (std::out_of_range& e) {
66680       {
66681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66682       };
66683     } catch (std::exception& e) {
66684       {
66685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66686       };
66687     } catch (Dali::DaliException e) {
66688       {
66689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66690       };
66691     } catch (...) {
66692       {
66693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66694       };
66695     }
66696   }
66697
66698   jresult = (void *)result;
66699   return jresult;
66700 }
66701
66702
66703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ImageView_DownCast(void * jarg1) {
66704   void * jresult ;
66705   Dali::BaseHandle arg1 ;
66706   Dali::BaseHandle *argp1 ;
66707   Dali::Toolkit::ImageView result;
66708
66709   argp1 = (Dali::BaseHandle *)jarg1;
66710   if (!argp1) {
66711     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
66712     return 0;
66713   }
66714   arg1 = *argp1;
66715   {
66716     try {
66717       result = Dali::Toolkit::ImageView::DownCast(arg1);
66718     } catch (std::out_of_range& e) {
66719       {
66720         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66721       };
66722     } catch (std::exception& e) {
66723       {
66724         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66725       };
66726     } catch (Dali::DaliException e) {
66727       {
66728         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66729       };
66730     } catch (...) {
66731       {
66732         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66733       };
66734     }
66735   }
66736
66737   jresult = new Dali::Toolkit::ImageView((const Dali::Toolkit::ImageView &)result);
66738   return jresult;
66739 }
66740
66741
66742 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_1(void * jarg1, char * jarg2) {
66743   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66744   std::string *arg2 = 0 ;
66745
66746   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66747   if (!jarg2) {
66748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66749     return ;
66750   }
66751   std::string arg2_str(jarg2);
66752   arg2 = &arg2_str;
66753   {
66754     try {
66755       (arg1)->SetImage((std::string const &)*arg2);
66756     } catch (std::out_of_range& e) {
66757       {
66758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66759       };
66760     } catch (std::exception& e) {
66761       {
66762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66763       };
66764     } catch (Dali::DaliException e) {
66765       {
66766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66767       };
66768     } catch (...) {
66769       {
66770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66771       };
66772     }
66773   }
66774
66775
66776   //argout typemap for const std::string&
66777
66778 }
66779
66780
66781 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ImageView_SetImage__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
66782   Dali::Toolkit::ImageView *arg1 = (Dali::Toolkit::ImageView *) 0 ;
66783   std::string *arg2 = 0 ;
66784   Dali::ImageDimensions arg3 ;
66785   Dali::ImageDimensions *argp3 ;
66786
66787   arg1 = (Dali::Toolkit::ImageView *)jarg1;
66788   if (!jarg2) {
66789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
66790     return ;
66791   }
66792   std::string arg2_str(jarg2);
66793   arg2 = &arg2_str;
66794   argp3 = (Dali::ImageDimensions *)jarg3;
66795   if (!argp3) {
66796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
66797     return ;
66798   }
66799   arg3 = *argp3;
66800   {
66801     try {
66802       (arg1)->SetImage((std::string const &)*arg2,arg3);
66803     } catch (std::out_of_range& e) {
66804       {
66805         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66806       };
66807     } catch (std::exception& e) {
66808       {
66809         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66810       };
66811     } catch (Dali::DaliException e) {
66812       {
66813         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66814       };
66815     } catch (...) {
66816       {
66817         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66818       };
66819     }
66820   }
66821
66822
66823   //argout typemap for const std::string&
66824
66825 }
66826
66827
66828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_GEOMETRY_URL_get() {
66829   int jresult ;
66830   int result;
66831
66832   result = (int)Dali::Toolkit::Model3dView::Property::GEOMETRY_URL;
66833   jresult = (int)result;
66834   return jresult;
66835 }
66836
66837
66838 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_MATERIAL_URL_get() {
66839   int jresult ;
66840   int result;
66841
66842   result = (int)Dali::Toolkit::Model3dView::Property::MATERIAL_URL;
66843   jresult = (int)result;
66844   return jresult;
66845 }
66846
66847
66848 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_IMAGES_URL_get() {
66849   int jresult ;
66850   int result;
66851
66852   result = (int)Dali::Toolkit::Model3dView::Property::IMAGES_URL;
66853   jresult = (int)result;
66854   return jresult;
66855 }
66856
66857
66858 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_ILLUMINATION_TYPE_get() {
66859   int jresult ;
66860   int result;
66861
66862   result = (int)Dali::Toolkit::Model3dView::Property::ILLUMINATION_TYPE;
66863   jresult = (int)result;
66864   return jresult;
66865 }
66866
66867
66868 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE0_URL_get() {
66869   int jresult ;
66870   int result;
66871
66872   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE0_URL;
66873   jresult = (int)result;
66874   return jresult;
66875 }
66876
66877
66878 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE1_URL_get() {
66879   int jresult ;
66880   int result;
66881
66882   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE1_URL;
66883   jresult = (int)result;
66884   return jresult;
66885 }
66886
66887
66888 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_TEXTURE2_URL_get() {
66889   int jresult ;
66890   int result;
66891
66892   result = (int)Dali::Toolkit::Model3dView::Property::TEXTURE2_URL;
66893   jresult = (int)result;
66894   return jresult;
66895 }
66896
66897
66898 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Model3dView_Property_LIGHT_POSITION_get() {
66899   int jresult ;
66900   int result;
66901
66902   result = (int)Dali::Toolkit::Model3dView::Property::LIGHT_POSITION;
66903   jresult = (int)result;
66904   return jresult;
66905 }
66906
66907
66908 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView_Property() {
66909   void * jresult ;
66910   Dali::Toolkit::Model3dView::Property *result = 0 ;
66911
66912   {
66913     try {
66914       result = (Dali::Toolkit::Model3dView::Property *)new Dali::Toolkit::Model3dView::Property();
66915     } catch (std::out_of_range& e) {
66916       {
66917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66918       };
66919     } catch (std::exception& e) {
66920       {
66921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66922       };
66923     } catch (Dali::DaliException e) {
66924       {
66925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66926       };
66927     } catch (...) {
66928       {
66929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66930       };
66931     }
66932   }
66933
66934   jresult = (void *)result;
66935   return jresult;
66936 }
66937
66938
66939 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView_Property(void * jarg1) {
66940   Dali::Toolkit::Model3dView::Property *arg1 = (Dali::Toolkit::Model3dView::Property *) 0 ;
66941
66942   arg1 = (Dali::Toolkit::Model3dView::Property *)jarg1;
66943   {
66944     try {
66945       delete arg1;
66946     } catch (std::out_of_range& e) {
66947       {
66948         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
66949       };
66950     } catch (std::exception& e) {
66951       {
66952         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
66953       };
66954     } catch (Dali::DaliException e) {
66955       {
66956         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
66957       };
66958     } catch (...) {
66959       {
66960         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
66961       };
66962     }
66963   }
66964
66965 }
66966
66967
66968 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_0() {
66969   void * jresult ;
66970   Dali::Toolkit::Model3dView result;
66971
66972   {
66973     try {
66974       result = Dali::Toolkit::Model3dView::New();
66975     } catch (std::out_of_range& e) {
66976       {
66977         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
66978       };
66979     } catch (std::exception& e) {
66980       {
66981         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
66982       };
66983     } catch (Dali::DaliException e) {
66984       {
66985         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
66986       };
66987     } catch (...) {
66988       {
66989         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
66990       };
66991     }
66992   }
66993
66994   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
66995   return jresult;
66996 }
66997
66998
66999 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_New__SWIG_1(char * jarg1, char * jarg2, char * jarg3) {
67000   void * jresult ;
67001   std::string *arg1 = 0 ;
67002   std::string *arg2 = 0 ;
67003   std::string *arg3 = 0 ;
67004   Dali::Toolkit::Model3dView result;
67005
67006   if (!jarg1) {
67007     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67008     return 0;
67009   }
67010   std::string arg1_str(jarg1);
67011   arg1 = &arg1_str;
67012   if (!jarg2) {
67013     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67014     return 0;
67015   }
67016   std::string arg2_str(jarg2);
67017   arg2 = &arg2_str;
67018   if (!jarg3) {
67019     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
67020     return 0;
67021   }
67022   std::string arg3_str(jarg3);
67023   arg3 = &arg3_str;
67024   {
67025     try {
67026       result = Dali::Toolkit::Model3dView::New((std::string const &)*arg1,(std::string const &)*arg2,(std::string const &)*arg3);
67027     } catch (std::out_of_range& e) {
67028       {
67029         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67030       };
67031     } catch (std::exception& e) {
67032       {
67033         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67034       };
67035     } catch (Dali::DaliException e) {
67036       {
67037         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67038       };
67039     } catch (...) {
67040       {
67041         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67042       };
67043     }
67044   }
67045
67046   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67047
67048   //argout typemap for const std::string&
67049
67050
67051   //argout typemap for const std::string&
67052
67053
67054   //argout typemap for const std::string&
67055
67056   return jresult;
67057 }
67058
67059
67060 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_0() {
67061   void * jresult ;
67062   Dali::Toolkit::Model3dView *result = 0 ;
67063
67064   {
67065     try {
67066       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView();
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 = (void *)result;
67087   return jresult;
67088 }
67089
67090
67091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Model3dView(void * jarg1) {
67092   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67093
67094   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67095   {
67096     try {
67097       delete arg1;
67098     } catch (std::out_of_range& e) {
67099       {
67100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67101       };
67102     } catch (std::exception& e) {
67103       {
67104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67105       };
67106     } catch (Dali::DaliException e) {
67107       {
67108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67109       };
67110     } catch (...) {
67111       {
67112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67113       };
67114     }
67115   }
67116
67117 }
67118
67119
67120 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Model3dView__SWIG_1(void * jarg1) {
67121   void * jresult ;
67122   Dali::Toolkit::Model3dView *arg1 = 0 ;
67123   Dali::Toolkit::Model3dView *result = 0 ;
67124
67125   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67126   if (!arg1) {
67127     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67128     return 0;
67129   }
67130   {
67131     try {
67132       result = (Dali::Toolkit::Model3dView *)new Dali::Toolkit::Model3dView((Dali::Toolkit::Model3dView const &)*arg1);
67133     } catch (std::out_of_range& e) {
67134       {
67135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67136       };
67137     } catch (std::exception& e) {
67138       {
67139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67140       };
67141     } catch (Dali::DaliException e) {
67142       {
67143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67144       };
67145     } catch (...) {
67146       {
67147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67148       };
67149     }
67150   }
67151
67152   jresult = (void *)result;
67153   return jresult;
67154 }
67155
67156
67157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_Assign(void * jarg1, void * jarg2) {
67158   void * jresult ;
67159   Dali::Toolkit::Model3dView *arg1 = (Dali::Toolkit::Model3dView *) 0 ;
67160   Dali::Toolkit::Model3dView *arg2 = 0 ;
67161   Dali::Toolkit::Model3dView *result = 0 ;
67162
67163   arg1 = (Dali::Toolkit::Model3dView *)jarg1;
67164   arg2 = (Dali::Toolkit::Model3dView *)jarg2;
67165   if (!arg2) {
67166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Model3dView const & type is null", 0);
67167     return 0;
67168   }
67169   {
67170     try {
67171       result = (Dali::Toolkit::Model3dView *) &(arg1)->operator =((Dali::Toolkit::Model3dView const &)*arg2);
67172     } catch (std::out_of_range& e) {
67173       {
67174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67175       };
67176     } catch (std::exception& e) {
67177       {
67178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67179       };
67180     } catch (Dali::DaliException e) {
67181       {
67182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67183       };
67184     } catch (...) {
67185       {
67186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67187       };
67188     }
67189   }
67190
67191   jresult = (void *)result;
67192   return jresult;
67193 }
67194
67195
67196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Model3dView_DownCast(void * jarg1) {
67197   void * jresult ;
67198   Dali::BaseHandle arg1 ;
67199   Dali::BaseHandle *argp1 ;
67200   Dali::Toolkit::Model3dView result;
67201
67202   argp1 = (Dali::BaseHandle *)jarg1;
67203   if (!argp1) {
67204     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67205     return 0;
67206   }
67207   arg1 = *argp1;
67208   {
67209     try {
67210       result = Dali::Toolkit::Model3dView::DownCast(arg1);
67211     } catch (std::out_of_range& e) {
67212       {
67213         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67214       };
67215     } catch (std::exception& e) {
67216       {
67217         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67218       };
67219     } catch (Dali::DaliException e) {
67220       {
67221         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67222       };
67223     } catch (...) {
67224       {
67225         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67226       };
67227     }
67228   }
67229
67230   jresult = new Dali::Toolkit::Model3dView((const Dali::Toolkit::Model3dView &)result);
67231   return jresult;
67232 }
67233
67234
67235 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_DIRECTION_get() {
67236   int jresult ;
67237   int result;
67238
67239   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_DIRECTION;
67240   jresult = (int)result;
67241   return jresult;
67242 }
67243
67244
67245 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HEIGHT_POLICY_get() {
67246   int jresult ;
67247   int result;
67248
67249   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HEIGHT_POLICY;
67250   jresult = (int)result;
67251   return jresult;
67252 }
67253
67254
67255 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_FIXED_HEIGHT_get() {
67256   int jresult ;
67257   int result;
67258
67259   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_FIXED_HEIGHT;
67260   jresult = (int)result;
67261   return jresult;
67262 }
67263
67264
67265 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_SHOW_DURATION_get() {
67266   int jresult ;
67267   int result;
67268
67269   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_SHOW_DURATION;
67270   jresult = (int)result;
67271   return jresult;
67272 }
67273
67274
67275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_HIDE_DURATION_get() {
67276   int jresult ;
67277   int result;
67278
67279   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_HIDE_DURATION;
67280   jresult = (int)result;
67281   return jresult;
67282 }
67283
67284
67285 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_SCROLL_POSITION_INTERVALS_get() {
67286   int jresult ;
67287   int result;
67288
67289   result = (int)Dali::Toolkit::ScrollBar::Property::SCROLL_POSITION_INTERVALS;
67290   jresult = (int)result;
67291   return jresult;
67292 }
67293
67294
67295 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_MINIMUM_HEIGHT_get() {
67296   int jresult ;
67297   int result;
67298
67299   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_MINIMUM_HEIGHT;
67300   jresult = (int)result;
67301   return jresult;
67302 }
67303
67304
67305 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_START_PADDING_get() {
67306   int jresult ;
67307   int result;
67308
67309   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_START_PADDING;
67310   jresult = (int)result;
67311   return jresult;
67312 }
67313
67314
67315 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_Property_INDICATOR_END_PADDING_get() {
67316   int jresult ;
67317   int result;
67318
67319   result = (int)Dali::Toolkit::ScrollBar::Property::INDICATOR_END_PADDING;
67320   jresult = (int)result;
67321   return jresult;
67322 }
67323
67324
67325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar_Property() {
67326   void * jresult ;
67327   Dali::Toolkit::ScrollBar::Property *result = 0 ;
67328
67329   {
67330     try {
67331       result = (Dali::Toolkit::ScrollBar::Property *)new Dali::Toolkit::ScrollBar::Property();
67332     } catch (std::out_of_range& e) {
67333       {
67334         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67335       };
67336     } catch (std::exception& e) {
67337       {
67338         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67339       };
67340     } catch (Dali::DaliException e) {
67341       {
67342         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67343       };
67344     } catch (...) {
67345       {
67346         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67347       };
67348     }
67349   }
67350
67351   jresult = (void *)result;
67352   return jresult;
67353 }
67354
67355
67356 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar_Property(void * jarg1) {
67357   Dali::Toolkit::ScrollBar::Property *arg1 = (Dali::Toolkit::ScrollBar::Property *) 0 ;
67358
67359   arg1 = (Dali::Toolkit::ScrollBar::Property *)jarg1;
67360   {
67361     try {
67362       delete arg1;
67363     } catch (std::out_of_range& e) {
67364       {
67365         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67366       };
67367     } catch (std::exception& e) {
67368       {
67369         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67370       };
67371     } catch (Dali::DaliException e) {
67372       {
67373         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67374       };
67375     } catch (...) {
67376       {
67377         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67378       };
67379     }
67380   }
67381
67382 }
67383
67384
67385 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_0() {
67386   void * jresult ;
67387   Dali::Toolkit::ScrollBar *result = 0 ;
67388
67389   {
67390     try {
67391       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar();
67392     } catch (std::out_of_range& e) {
67393       {
67394         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67395       };
67396     } catch (std::exception& e) {
67397       {
67398         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67399       };
67400     } catch (Dali::DaliException e) {
67401       {
67402         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67403       };
67404     } catch (...) {
67405       {
67406         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67407       };
67408     }
67409   }
67410
67411   jresult = (void *)result;
67412   return jresult;
67413 }
67414
67415
67416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollBar__SWIG_1(void * jarg1) {
67417   void * jresult ;
67418   Dali::Toolkit::ScrollBar *arg1 = 0 ;
67419   Dali::Toolkit::ScrollBar *result = 0 ;
67420
67421   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67422   if (!arg1) {
67423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67424     return 0;
67425   }
67426   {
67427     try {
67428       result = (Dali::Toolkit::ScrollBar *)new Dali::Toolkit::ScrollBar((Dali::Toolkit::ScrollBar const &)*arg1);
67429     } catch (std::out_of_range& e) {
67430       {
67431         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67432       };
67433     } catch (std::exception& e) {
67434       {
67435         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67436       };
67437     } catch (Dali::DaliException e) {
67438       {
67439         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67440       };
67441     } catch (...) {
67442       {
67443         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67444       };
67445     }
67446   }
67447
67448   jresult = (void *)result;
67449   return jresult;
67450 }
67451
67452
67453 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_Assign(void * jarg1, void * jarg2) {
67454   void * jresult ;
67455   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67456   Dali::Toolkit::ScrollBar *arg2 = 0 ;
67457   Dali::Toolkit::ScrollBar *result = 0 ;
67458
67459   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67460   arg2 = (Dali::Toolkit::ScrollBar *)jarg2;
67461   if (!arg2) {
67462     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollBar const & type is null", 0);
67463     return 0;
67464   }
67465   {
67466     try {
67467       result = (Dali::Toolkit::ScrollBar *) &(arg1)->operator =((Dali::Toolkit::ScrollBar const &)*arg2);
67468     } catch (std::out_of_range& e) {
67469       {
67470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67471       };
67472     } catch (std::exception& e) {
67473       {
67474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67475       };
67476     } catch (Dali::DaliException e) {
67477       {
67478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67479       };
67480     } catch (...) {
67481       {
67482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67483       };
67484     }
67485   }
67486
67487   jresult = (void *)result;
67488   return jresult;
67489 }
67490
67491
67492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollBar(void * jarg1) {
67493   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67494
67495   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67496   {
67497     try {
67498       delete arg1;
67499     } catch (std::out_of_range& e) {
67500       {
67501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67502       };
67503     } catch (std::exception& e) {
67504       {
67505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67506       };
67507     } catch (Dali::DaliException e) {
67508       {
67509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67510       };
67511     } catch (...) {
67512       {
67513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67514       };
67515     }
67516   }
67517
67518 }
67519
67520
67521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_0(int jarg1) {
67522   void * jresult ;
67523   Dali::Toolkit::ScrollBar::Direction arg1 ;
67524   Dali::Toolkit::ScrollBar result;
67525
67526   arg1 = (Dali::Toolkit::ScrollBar::Direction)jarg1;
67527   {
67528     try {
67529       result = Dali::Toolkit::ScrollBar::New(arg1);
67530     } catch (std::out_of_range& e) {
67531       {
67532         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67533       };
67534     } catch (std::exception& e) {
67535       {
67536         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67537       };
67538     } catch (Dali::DaliException e) {
67539       {
67540         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67541       };
67542     } catch (...) {
67543       {
67544         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67545       };
67546     }
67547   }
67548
67549   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67550   return jresult;
67551 }
67552
67553
67554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_New__SWIG_1() {
67555   void * jresult ;
67556   Dali::Toolkit::ScrollBar result;
67557
67558   {
67559     try {
67560       result = Dali::Toolkit::ScrollBar::New();
67561     } catch (std::out_of_range& e) {
67562       {
67563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67564       };
67565     } catch (std::exception& e) {
67566       {
67567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67568       };
67569     } catch (Dali::DaliException e) {
67570       {
67571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67572       };
67573     } catch (...) {
67574       {
67575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67576       };
67577     }
67578   }
67579
67580   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67581   return jresult;
67582 }
67583
67584
67585 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_DownCast(void * jarg1) {
67586   void * jresult ;
67587   Dali::BaseHandle arg1 ;
67588   Dali::BaseHandle *argp1 ;
67589   Dali::Toolkit::ScrollBar result;
67590
67591   argp1 = (Dali::BaseHandle *)jarg1;
67592   if (!argp1) {
67593     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
67594     return 0;
67595   }
67596   arg1 = *argp1;
67597   {
67598     try {
67599       result = Dali::Toolkit::ScrollBar::DownCast(arg1);
67600     } catch (std::out_of_range& e) {
67601       {
67602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67603       };
67604     } catch (std::exception& e) {
67605       {
67606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67607       };
67608     } catch (Dali::DaliException e) {
67609       {
67610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67611       };
67612     } catch (...) {
67613       {
67614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67615       };
67616     }
67617   }
67618
67619   jresult = new Dali::Toolkit::ScrollBar((const Dali::Toolkit::ScrollBar &)result);
67620   return jresult;
67621 }
67622
67623
67624 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPropertySource(void * jarg1, void * jarg2, int jarg3, int jarg4, int jarg5, int jarg6) {
67625   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67626   Dali::Handle arg2 ;
67627   Dali::Property::Index arg3 ;
67628   Dali::Property::Index arg4 ;
67629   Dali::Property::Index arg5 ;
67630   Dali::Property::Index arg6 ;
67631   Dali::Handle *argp2 ;
67632
67633   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67634   argp2 = (Dali::Handle *)jarg2;
67635   if (!argp2) {
67636     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Handle", 0);
67637     return ;
67638   }
67639   arg2 = *argp2;
67640   arg3 = (Dali::Property::Index)jarg3;
67641   arg4 = (Dali::Property::Index)jarg4;
67642   arg5 = (Dali::Property::Index)jarg5;
67643   arg6 = (Dali::Property::Index)jarg6;
67644   {
67645     try {
67646       (arg1)->SetScrollPropertySource(arg2,arg3,arg4,arg5,arg6);
67647     } catch (std::out_of_range& e) {
67648       {
67649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67650       };
67651     } catch (std::exception& e) {
67652       {
67653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67654       };
67655     } catch (Dali::DaliException e) {
67656       {
67657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67658       };
67659     } catch (...) {
67660       {
67661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67662       };
67663     }
67664   }
67665
67666 }
67667
67668
67669 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollIndicator(void * jarg1, void * jarg2) {
67670   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67671   Dali::Actor arg2 ;
67672   Dali::Actor *argp2 ;
67673
67674   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67675   argp2 = (Dali::Actor *)jarg2;
67676   if (!argp2) {
67677     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
67678     return ;
67679   }
67680   arg2 = *argp2;
67681   {
67682     try {
67683       (arg1)->SetScrollIndicator(arg2);
67684     } catch (std::out_of_range& e) {
67685       {
67686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67687       };
67688     } catch (std::exception& e) {
67689       {
67690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67691       };
67692     } catch (Dali::DaliException e) {
67693       {
67694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67695       };
67696     } catch (...) {
67697       {
67698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67699       };
67700     }
67701   }
67702
67703 }
67704
67705
67706 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollIndicator(void * jarg1) {
67707   void * jresult ;
67708   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67709   Dali::Actor result;
67710
67711   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67712   {
67713     try {
67714       result = (arg1)->GetScrollIndicator();
67715     } catch (std::out_of_range& e) {
67716       {
67717         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67718       };
67719     } catch (std::exception& e) {
67720       {
67721         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67722       };
67723     } catch (Dali::DaliException e) {
67724       {
67725         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67726       };
67727     } catch (...) {
67728       {
67729         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67730       };
67731     }
67732   }
67733
67734   jresult = new Dali::Actor((const Dali::Actor &)result);
67735   return jresult;
67736 }
67737
67738
67739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollPositionIntervals(void * jarg1, void * jarg2) {
67740   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67741   Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *arg2 = 0 ;
67742
67743   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67744   arg2 = (Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > *)jarg2;
67745   if (!arg2) {
67746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const & type is null", 0);
67747     return ;
67748   }
67749   {
67750     try {
67751       (arg1)->SetScrollPositionIntervals((Dali::Vector< float,TypeTraits< float >::IS_TRIVIAL_TYPE==true > const &)*arg2);
67752     } catch (std::out_of_range& e) {
67753       {
67754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67755       };
67756     } catch (std::exception& e) {
67757       {
67758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67759       };
67760     } catch (Dali::DaliException e) {
67761       {
67762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67763       };
67764     } catch (...) {
67765       {
67766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67767       };
67768     }
67769   }
67770
67771 }
67772
67773
67774 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollPositionIntervals(void * jarg1) {
67775   void * jresult ;
67776   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67777
67778   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67779   {
67780     try {
67781       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()));
67782     } catch (std::out_of_range& e) {
67783       {
67784         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67785       };
67786     } catch (std::exception& e) {
67787       {
67788         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67789       };
67790     } catch (...) {
67791       {
67792         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67793       };
67794     }
67795   }
67796   return jresult;
67797 }
67798
67799
67800 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetScrollDirection(void * jarg1, int jarg2) {
67801   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67802   Dali::Toolkit::ScrollBar::Direction arg2 ;
67803
67804   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67805   arg2 = (Dali::Toolkit::ScrollBar::Direction)jarg2;
67806   {
67807     try {
67808       (arg1)->SetScrollDirection(arg2);
67809     } catch (std::out_of_range& e) {
67810       {
67811         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67812       };
67813     } catch (std::exception& e) {
67814       {
67815         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67816       };
67817     } catch (Dali::DaliException e) {
67818       {
67819         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67820       };
67821     } catch (...) {
67822       {
67823         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67824       };
67825     }
67826   }
67827
67828 }
67829
67830
67831 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetScrollDirection(void * jarg1) {
67832   int jresult ;
67833   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67834   Dali::Toolkit::ScrollBar::Direction result;
67835
67836   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67837   {
67838     try {
67839       result = (Dali::Toolkit::ScrollBar::Direction)((Dali::Toolkit::ScrollBar const *)arg1)->GetScrollDirection();
67840     } catch (std::out_of_range& e) {
67841       {
67842         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67843       };
67844     } catch (std::exception& e) {
67845       {
67846         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67847       };
67848     } catch (Dali::DaliException e) {
67849       {
67850         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67851       };
67852     } catch (...) {
67853       {
67854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67855       };
67856     }
67857   }
67858
67859   jresult = (int)result;
67860   return jresult;
67861 }
67862
67863
67864 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHeightPolicy(void * jarg1, int jarg2) {
67865   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67866   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy arg2 ;
67867
67868   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67869   arg2 = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)jarg2;
67870   {
67871     try {
67872       (arg1)->SetIndicatorHeightPolicy(arg2);
67873     } catch (std::out_of_range& e) {
67874       {
67875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67876       };
67877     } catch (std::exception& e) {
67878       {
67879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67880       };
67881     } catch (Dali::DaliException e) {
67882       {
67883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67884       };
67885     } catch (...) {
67886       {
67887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67888       };
67889     }
67890   }
67891
67892 }
67893
67894
67895 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHeightPolicy(void * jarg1) {
67896   int jresult ;
67897   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67898   Dali::Toolkit::ScrollBar::IndicatorHeightPolicy result;
67899
67900   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67901   {
67902     try {
67903       result = (Dali::Toolkit::ScrollBar::IndicatorHeightPolicy)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHeightPolicy();
67904     } catch (std::out_of_range& e) {
67905       {
67906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67907       };
67908     } catch (std::exception& e) {
67909       {
67910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67911       };
67912     } catch (Dali::DaliException e) {
67913       {
67914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67915       };
67916     } catch (...) {
67917       {
67918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67919       };
67920     }
67921   }
67922
67923   jresult = (int)result;
67924   return jresult;
67925 }
67926
67927
67928 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorFixedHeight(void * jarg1, float jarg2) {
67929   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67930   float arg2 ;
67931
67932   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67933   arg2 = (float)jarg2;
67934   {
67935     try {
67936       (arg1)->SetIndicatorFixedHeight(arg2);
67937     } catch (std::out_of_range& e) {
67938       {
67939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
67940       };
67941     } catch (std::exception& e) {
67942       {
67943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
67944       };
67945     } catch (Dali::DaliException e) {
67946       {
67947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
67948       };
67949     } catch (...) {
67950       {
67951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
67952       };
67953     }
67954   }
67955
67956 }
67957
67958
67959 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorFixedHeight(void * jarg1) {
67960   float jresult ;
67961   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67962   float result;
67963
67964   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67965   {
67966     try {
67967       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorFixedHeight();
67968     } catch (std::out_of_range& e) {
67969       {
67970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
67971       };
67972     } catch (std::exception& e) {
67973       {
67974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
67975       };
67976     } catch (Dali::DaliException e) {
67977       {
67978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
67979       };
67980     } catch (...) {
67981       {
67982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
67983       };
67984     }
67985   }
67986
67987   jresult = result;
67988   return jresult;
67989 }
67990
67991
67992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorShowDuration(void * jarg1, float jarg2) {
67993   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
67994   float arg2 ;
67995
67996   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
67997   arg2 = (float)jarg2;
67998   {
67999     try {
68000       (arg1)->SetIndicatorShowDuration(arg2);
68001     } catch (std::out_of_range& e) {
68002       {
68003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68004       };
68005     } catch (std::exception& e) {
68006       {
68007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68008       };
68009     } catch (Dali::DaliException e) {
68010       {
68011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68012       };
68013     } catch (...) {
68014       {
68015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68016       };
68017     }
68018   }
68019
68020 }
68021
68022
68023 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorShowDuration(void * jarg1) {
68024   float jresult ;
68025   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68026   float result;
68027
68028   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68029   {
68030     try {
68031       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorShowDuration();
68032     } catch (std::out_of_range& e) {
68033       {
68034         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68035       };
68036     } catch (std::exception& e) {
68037       {
68038         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68039       };
68040     } catch (Dali::DaliException e) {
68041       {
68042         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68043       };
68044     } catch (...) {
68045       {
68046         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68047       };
68048     }
68049   }
68050
68051   jresult = result;
68052   return jresult;
68053 }
68054
68055
68056 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_SetIndicatorHideDuration(void * jarg1, float jarg2) {
68057   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68058   float arg2 ;
68059
68060   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68061   arg2 = (float)jarg2;
68062   {
68063     try {
68064       (arg1)->SetIndicatorHideDuration(arg2);
68065     } catch (std::out_of_range& e) {
68066       {
68067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68068       };
68069     } catch (std::exception& e) {
68070       {
68071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68072       };
68073     } catch (Dali::DaliException e) {
68074       {
68075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68076       };
68077     } catch (...) {
68078       {
68079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68080       };
68081     }
68082   }
68083
68084 }
68085
68086
68087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollBar_GetIndicatorHideDuration(void * jarg1) {
68088   float jresult ;
68089   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68090   float result;
68091
68092   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68093   {
68094     try {
68095       result = (float)((Dali::Toolkit::ScrollBar const *)arg1)->GetIndicatorHideDuration();
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 = result;
68116   return jresult;
68117 }
68118
68119
68120 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_ShowIndicator(void * jarg1) {
68121   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68122
68123   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68124   {
68125     try {
68126       (arg1)->ShowIndicator();
68127     } catch (std::out_of_range& e) {
68128       {
68129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68130       };
68131     } catch (std::exception& e) {
68132       {
68133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68134       };
68135     } catch (Dali::DaliException e) {
68136       {
68137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68138       };
68139     } catch (...) {
68140       {
68141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68142       };
68143     }
68144   }
68145
68146 }
68147
68148
68149 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollBar_HideIndicator(void * jarg1) {
68150   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68151
68152   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68153   {
68154     try {
68155       (arg1)->HideIndicator();
68156     } catch (std::out_of_range& e) {
68157       {
68158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68159       };
68160     } catch (std::exception& e) {
68161       {
68162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68163       };
68164     } catch (Dali::DaliException e) {
68165       {
68166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68167       };
68168     } catch (...) {
68169       {
68170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68171       };
68172     }
68173   }
68174
68175 }
68176
68177
68178 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_PanFinishedSignal(void * jarg1) {
68179   void * jresult ;
68180   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68181   Dali::Toolkit::ScrollBar::PanFinishedSignalType *result = 0 ;
68182
68183   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68184   {
68185     try {
68186       result = (Dali::Toolkit::ScrollBar::PanFinishedSignalType *) &(arg1)->PanFinishedSignal();
68187     } catch (std::out_of_range& e) {
68188       {
68189         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68190       };
68191     } catch (std::exception& e) {
68192       {
68193         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68194       };
68195     } catch (Dali::DaliException e) {
68196       {
68197         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68198       };
68199     } catch (...) {
68200       {
68201         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68202       };
68203     }
68204   }
68205
68206   jresult = (void *)result;
68207   return jresult;
68208 }
68209
68210
68211 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollBar_ScrollPositionIntervalReachedSignal(void * jarg1) {
68212   void * jresult ;
68213   Dali::Toolkit::ScrollBar *arg1 = (Dali::Toolkit::ScrollBar *) 0 ;
68214   Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *result = 0 ;
68215
68216   arg1 = (Dali::Toolkit::ScrollBar *)jarg1;
68217   {
68218     try {
68219       result = (Dali::Toolkit::ScrollBar::ScrollPositionIntervalReachedSignalType *) &(arg1)->ScrollPositionIntervalReachedSignal();
68220     } catch (std::out_of_range& e) {
68221       {
68222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68223       };
68224     } catch (std::exception& e) {
68225       {
68226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68227       };
68228     } catch (Dali::DaliException e) {
68229       {
68230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68231       };
68232     } catch (...) {
68233       {
68234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68235       };
68236     }
68237   }
68238
68239   jresult = (void *)result;
68240   return jresult;
68241 }
68242
68243
68244 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_EFFECT_COLOR_get() {
68245   int jresult ;
68246   int result;
68247
68248   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_EFFECT_COLOR;
68249   jresult = (int)result;
68250   return jresult;
68251 }
68252
68253
68254 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ANIMATION_SPEED_get() {
68255   int jresult ;
68256   int result;
68257
68258   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ANIMATION_SPEED;
68259   jresult = (int)result;
68260   return jresult;
68261 }
68262
68263
68264 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_ENABLED_get() {
68265   int jresult ;
68266   int result;
68267
68268   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_ENABLED;
68269   jresult = (int)result;
68270   return jresult;
68271 }
68272
68273
68274 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_OVERSHOOT_SIZE_get() {
68275   int jresult ;
68276   int result;
68277
68278   result = (int)Dali::Toolkit::Scrollable::Property::OVERSHOOT_SIZE;
68279   jresult = (int)result;
68280   return jresult;
68281 }
68282
68283
68284 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_TO_ALPHA_FUNCTION_get() {
68285   int jresult ;
68286   int result;
68287
68288   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_TO_ALPHA_FUNCTION;
68289   jresult = (int)result;
68290   return jresult;
68291 }
68292
68293
68294 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_RELATIVE_POSITION_get() {
68295   int jresult ;
68296   int result;
68297
68298   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_RELATIVE_POSITION;
68299   jresult = (int)result;
68300   return jresult;
68301 }
68302
68303
68304 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_get() {
68305   int jresult ;
68306   int result;
68307
68308   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN;
68309   jresult = (int)result;
68310   return jresult;
68311 }
68312
68313
68314 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_X_get() {
68315   int jresult ;
68316   int result;
68317
68318   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_X;
68319   jresult = (int)result;
68320   return jresult;
68321 }
68322
68323
68324 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MIN_Y_get() {
68325   int jresult ;
68326   int result;
68327
68328   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MIN_Y;
68329   jresult = (int)result;
68330   return jresult;
68331 }
68332
68333
68334 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_get() {
68335   int jresult ;
68336   int result;
68337
68338   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX;
68339   jresult = (int)result;
68340   return jresult;
68341 }
68342
68343
68344 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_X_get() {
68345   int jresult ;
68346   int result;
68347
68348   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_X;
68349   jresult = (int)result;
68350   return jresult;
68351 }
68352
68353
68354 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_SCROLL_POSITION_MAX_Y_get() {
68355   int jresult ;
68356   int result;
68357
68358   result = (int)Dali::Toolkit::Scrollable::Property::SCROLL_POSITION_MAX_Y;
68359   jresult = (int)result;
68360   return jresult;
68361 }
68362
68363
68364 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_VERTICAL_get() {
68365   int jresult ;
68366   int result;
68367
68368   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_VERTICAL;
68369   jresult = (int)result;
68370   return jresult;
68371 }
68372
68373
68374 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Scrollable_Property_CAN_SCROLL_HORIZONTAL_get() {
68375   int jresult ;
68376   int result;
68377
68378   result = (int)Dali::Toolkit::Scrollable::Property::CAN_SCROLL_HORIZONTAL;
68379   jresult = (int)result;
68380   return jresult;
68381 }
68382
68383
68384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable_Property() {
68385   void * jresult ;
68386   Dali::Toolkit::Scrollable::Property *result = 0 ;
68387
68388   {
68389     try {
68390       result = (Dali::Toolkit::Scrollable::Property *)new Dali::Toolkit::Scrollable::Property();
68391     } catch (std::out_of_range& e) {
68392       {
68393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68394       };
68395     } catch (std::exception& e) {
68396       {
68397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68398       };
68399     } catch (Dali::DaliException e) {
68400       {
68401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68402       };
68403     } catch (...) {
68404       {
68405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68406       };
68407     }
68408   }
68409
68410   jresult = (void *)result;
68411   return jresult;
68412 }
68413
68414
68415 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable_Property(void * jarg1) {
68416   Dali::Toolkit::Scrollable::Property *arg1 = (Dali::Toolkit::Scrollable::Property *) 0 ;
68417
68418   arg1 = (Dali::Toolkit::Scrollable::Property *)jarg1;
68419   {
68420     try {
68421       delete arg1;
68422     } catch (std::out_of_range& e) {
68423       {
68424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68425       };
68426     } catch (std::exception& e) {
68427       {
68428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68429       };
68430     } catch (Dali::DaliException e) {
68431       {
68432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68433       };
68434     } catch (...) {
68435       {
68436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68437       };
68438     }
68439   }
68440
68441 }
68442
68443
68444 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_0() {
68445   void * jresult ;
68446   Dali::Toolkit::Scrollable *result = 0 ;
68447
68448   {
68449     try {
68450       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable();
68451     } catch (std::out_of_range& e) {
68452       {
68453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68454       };
68455     } catch (std::exception& e) {
68456       {
68457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68458       };
68459     } catch (Dali::DaliException e) {
68460       {
68461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68462       };
68463     } catch (...) {
68464       {
68465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68466       };
68467     }
68468   }
68469
68470   jresult = (void *)result;
68471   return jresult;
68472 }
68473
68474
68475 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Scrollable__SWIG_1(void * jarg1) {
68476   void * jresult ;
68477   Dali::Toolkit::Scrollable *arg1 = 0 ;
68478   Dali::Toolkit::Scrollable *result = 0 ;
68479
68480   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68481   if (!arg1) {
68482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68483     return 0;
68484   }
68485   {
68486     try {
68487       result = (Dali::Toolkit::Scrollable *)new Dali::Toolkit::Scrollable((Dali::Toolkit::Scrollable const &)*arg1);
68488     } catch (std::out_of_range& e) {
68489       {
68490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68491       };
68492     } catch (std::exception& e) {
68493       {
68494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68495       };
68496     } catch (Dali::DaliException e) {
68497       {
68498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68499       };
68500     } catch (...) {
68501       {
68502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68503       };
68504     }
68505   }
68506
68507   jresult = (void *)result;
68508   return jresult;
68509 }
68510
68511
68512 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_Assign(void * jarg1, void * jarg2) {
68513   void * jresult ;
68514   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68515   Dali::Toolkit::Scrollable *arg2 = 0 ;
68516   Dali::Toolkit::Scrollable *result = 0 ;
68517
68518   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68519   arg2 = (Dali::Toolkit::Scrollable *)jarg2;
68520   if (!arg2) {
68521     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Scrollable const & type is null", 0);
68522     return 0;
68523   }
68524   {
68525     try {
68526       result = (Dali::Toolkit::Scrollable *) &(arg1)->operator =((Dali::Toolkit::Scrollable const &)*arg2);
68527     } catch (std::out_of_range& e) {
68528       {
68529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68530       };
68531     } catch (std::exception& e) {
68532       {
68533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68534       };
68535     } catch (Dali::DaliException e) {
68536       {
68537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68538       };
68539     } catch (...) {
68540       {
68541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68542       };
68543     }
68544   }
68545
68546   jresult = (void *)result;
68547   return jresult;
68548 }
68549
68550
68551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Scrollable(void * jarg1) {
68552   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68553
68554   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68555   {
68556     try {
68557       delete arg1;
68558     } catch (std::out_of_range& e) {
68559       {
68560         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68561       };
68562     } catch (std::exception& e) {
68563       {
68564         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68565       };
68566     } catch (Dali::DaliException e) {
68567       {
68568         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68569       };
68570     } catch (...) {
68571       {
68572         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68573       };
68574     }
68575   }
68576
68577 }
68578
68579
68580 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_DownCast(void * jarg1) {
68581   void * jresult ;
68582   Dali::BaseHandle arg1 ;
68583   Dali::BaseHandle *argp1 ;
68584   Dali::Toolkit::Scrollable result;
68585
68586   argp1 = (Dali::BaseHandle *)jarg1;
68587   if (!argp1) {
68588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
68589     return 0;
68590   }
68591   arg1 = *argp1;
68592   {
68593     try {
68594       result = Dali::Toolkit::Scrollable::DownCast(arg1);
68595     } catch (std::out_of_range& e) {
68596       {
68597         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68598       };
68599     } catch (std::exception& e) {
68600       {
68601         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68602       };
68603     } catch (Dali::DaliException e) {
68604       {
68605         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68606       };
68607     } catch (...) {
68608       {
68609         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68610       };
68611     }
68612   }
68613
68614   jresult = new Dali::Toolkit::Scrollable((const Dali::Toolkit::Scrollable &)result);
68615   return jresult;
68616 }
68617
68618
68619 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Scrollable_IsOvershootEnabled(void * jarg1) {
68620   unsigned int jresult ;
68621   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68622   bool result;
68623
68624   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68625   {
68626     try {
68627       result = (bool)((Dali::Toolkit::Scrollable const *)arg1)->IsOvershootEnabled();
68628     } catch (std::out_of_range& e) {
68629       {
68630         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68631       };
68632     } catch (std::exception& e) {
68633       {
68634         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68635       };
68636     } catch (Dali::DaliException e) {
68637       {
68638         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68639       };
68640     } catch (...) {
68641       {
68642         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68643       };
68644     }
68645   }
68646
68647   jresult = result;
68648   return jresult;
68649 }
68650
68651
68652 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEnabled(void * jarg1, unsigned int jarg2) {
68653   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68654   bool arg2 ;
68655
68656   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68657   arg2 = jarg2 ? true : false;
68658   {
68659     try {
68660       (arg1)->SetOvershootEnabled(arg2);
68661     } catch (std::out_of_range& e) {
68662       {
68663         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68664       };
68665     } catch (std::exception& e) {
68666       {
68667         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68668       };
68669     } catch (Dali::DaliException e) {
68670       {
68671         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68672       };
68673     } catch (...) {
68674       {
68675         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68676       };
68677     }
68678   }
68679
68680 }
68681
68682
68683 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootEffectColor(void * jarg1, void * jarg2) {
68684   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68685   Dali::Vector4 *arg2 = 0 ;
68686
68687   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68688   arg2 = (Dali::Vector4 *)jarg2;
68689   if (!arg2) {
68690     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
68691     return ;
68692   }
68693   {
68694     try {
68695       (arg1)->SetOvershootEffectColor((Dali::Vector4 const &)*arg2);
68696     } catch (std::out_of_range& e) {
68697       {
68698         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68699       };
68700     } catch (std::exception& e) {
68701       {
68702         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68703       };
68704     } catch (Dali::DaliException e) {
68705       {
68706         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68707       };
68708     } catch (...) {
68709       {
68710         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68711       };
68712     }
68713   }
68714
68715 }
68716
68717
68718 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootEffectColor(void * jarg1) {
68719   void * jresult ;
68720   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68721   Dali::Vector4 result;
68722
68723   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68724   {
68725     try {
68726       result = ((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootEffectColor();
68727     } catch (std::out_of_range& e) {
68728       {
68729         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68730       };
68731     } catch (std::exception& e) {
68732       {
68733         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68734       };
68735     } catch (Dali::DaliException e) {
68736       {
68737         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68738       };
68739     } catch (...) {
68740       {
68741         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68742       };
68743     }
68744   }
68745
68746   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
68747   return jresult;
68748 }
68749
68750
68751 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Scrollable_SetOvershootAnimationSpeed(void * jarg1, float jarg2) {
68752   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68753   float arg2 ;
68754
68755   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68756   arg2 = (float)jarg2;
68757   {
68758     try {
68759       (arg1)->SetOvershootAnimationSpeed(arg2);
68760     } catch (std::out_of_range& e) {
68761       {
68762         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
68763       };
68764     } catch (std::exception& e) {
68765       {
68766         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
68767       };
68768     } catch (Dali::DaliException e) {
68769       {
68770         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
68771       };
68772     } catch (...) {
68773       {
68774         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
68775       };
68776     }
68777   }
68778
68779 }
68780
68781
68782 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Scrollable_GetOvershootAnimationSpeed(void * jarg1) {
68783   float jresult ;
68784   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68785   float result;
68786
68787   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68788   {
68789     try {
68790       result = (float)((Dali::Toolkit::Scrollable const *)arg1)->GetOvershootAnimationSpeed();
68791     } catch (std::out_of_range& e) {
68792       {
68793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68794       };
68795     } catch (std::exception& e) {
68796       {
68797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68798       };
68799     } catch (Dali::DaliException e) {
68800       {
68801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68802       };
68803     } catch (...) {
68804       {
68805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68806       };
68807     }
68808   }
68809
68810   jresult = result;
68811   return jresult;
68812 }
68813
68814
68815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollStartedSignal(void * jarg1) {
68816   void * jresult ;
68817   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68818   Dali::Toolkit::Scrollable::ScrollStartedSignalType *result = 0 ;
68819
68820   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68821   {
68822     try {
68823       result = (Dali::Toolkit::Scrollable::ScrollStartedSignalType *) &(arg1)->ScrollStartedSignal();
68824     } catch (std::out_of_range& e) {
68825       {
68826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68827       };
68828     } catch (std::exception& e) {
68829       {
68830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68831       };
68832     } catch (Dali::DaliException e) {
68833       {
68834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68835       };
68836     } catch (...) {
68837       {
68838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68839       };
68840     }
68841   }
68842
68843   jresult = (void *)result;
68844   return jresult;
68845 }
68846
68847
68848 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollUpdatedSignal(void * jarg1) {
68849   void * jresult ;
68850   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68851   Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *result = 0 ;
68852
68853   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68854   {
68855     try {
68856       result = (Dali::Toolkit::Scrollable::ScrollUpdatedSignalType *) &(arg1)->ScrollUpdatedSignal();
68857     } catch (std::out_of_range& e) {
68858       {
68859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68860       };
68861     } catch (std::exception& e) {
68862       {
68863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68864       };
68865     } catch (Dali::DaliException e) {
68866       {
68867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68868       };
68869     } catch (...) {
68870       {
68871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68872       };
68873     }
68874   }
68875
68876   jresult = (void *)result;
68877   return jresult;
68878 }
68879
68880
68881 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Scrollable_ScrollCompletedSignal(void * jarg1) {
68882   void * jresult ;
68883   Dali::Toolkit::Scrollable *arg1 = (Dali::Toolkit::Scrollable *) 0 ;
68884   Dali::Toolkit::Scrollable::ScrollCompletedSignalType *result = 0 ;
68885
68886   arg1 = (Dali::Toolkit::Scrollable *)jarg1;
68887   {
68888     try {
68889       result = (Dali::Toolkit::Scrollable::ScrollCompletedSignalType *) &(arg1)->ScrollCompletedSignal();
68890     } catch (std::out_of_range& e) {
68891       {
68892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68893       };
68894     } catch (std::exception& e) {
68895       {
68896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68897       };
68898     } catch (Dali::DaliException e) {
68899       {
68900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68901       };
68902     } catch (...) {
68903       {
68904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68905       };
68906     }
68907   }
68908
68909   jresult = (void *)result;
68910   return jresult;
68911 }
68912
68913
68914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsVertical(int jarg1) {
68915   unsigned int jresult ;
68916   Dali::Toolkit::ControlOrientation::Type arg1 ;
68917   bool result;
68918
68919   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68920   {
68921     try {
68922       result = (bool)Dali::Toolkit::IsVertical(arg1);
68923     } catch (std::out_of_range& e) {
68924       {
68925         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68926       };
68927     } catch (std::exception& e) {
68928       {
68929         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68930       };
68931     } catch (Dali::DaliException e) {
68932       {
68933         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68934       };
68935     } catch (...) {
68936       {
68937         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68938       };
68939     }
68940   }
68941
68942   jresult = result;
68943   return jresult;
68944 }
68945
68946
68947 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_IsHorizontal(int jarg1) {
68948   unsigned int jresult ;
68949   Dali::Toolkit::ControlOrientation::Type arg1 ;
68950   bool result;
68951
68952   arg1 = (Dali::Toolkit::ControlOrientation::Type)jarg1;
68953   {
68954     try {
68955       result = (bool)Dali::Toolkit::IsHorizontal(arg1);
68956     } catch (std::out_of_range& e) {
68957       {
68958         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68959       };
68960     } catch (std::exception& e) {
68961       {
68962         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68963       };
68964     } catch (Dali::DaliException e) {
68965       {
68966         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
68967       };
68968     } catch (...) {
68969       {
68970         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
68971       };
68972     }
68973   }
68974
68975   jresult = result;
68976   return jresult;
68977 }
68978
68979
68980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_0(unsigned int jarg1, unsigned int jarg2) {
68981   void * jresult ;
68982   unsigned int arg1 ;
68983   unsigned int arg2 ;
68984   Dali::Toolkit::ItemRange *result = 0 ;
68985
68986   arg1 = (unsigned int)jarg1;
68987   arg2 = (unsigned int)jarg2;
68988   {
68989     try {
68990       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange(arg1,arg2);
68991     } catch (std::out_of_range& e) {
68992       {
68993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
68994       };
68995     } catch (std::exception& e) {
68996       {
68997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
68998       };
68999     } catch (Dali::DaliException e) {
69000       {
69001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69002       };
69003     } catch (...) {
69004       {
69005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69006       };
69007     }
69008   }
69009
69010   jresult = (void *)result;
69011   return jresult;
69012 }
69013
69014
69015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemRange__SWIG_1(void * jarg1) {
69016   void * jresult ;
69017   Dali::Toolkit::ItemRange *arg1 = 0 ;
69018   Dali::Toolkit::ItemRange *result = 0 ;
69019
69020   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69021   if (!arg1) {
69022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69023     return 0;
69024   }
69025   {
69026     try {
69027       result = (Dali::Toolkit::ItemRange *)new Dali::Toolkit::ItemRange((Dali::Toolkit::ItemRange const &)*arg1);
69028     } catch (std::out_of_range& e) {
69029       {
69030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69031       };
69032     } catch (std::exception& e) {
69033       {
69034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69035       };
69036     } catch (Dali::DaliException e) {
69037       {
69038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69039       };
69040     } catch (...) {
69041       {
69042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69043       };
69044     }
69045   }
69046
69047   jresult = (void *)result;
69048   return jresult;
69049 }
69050
69051
69052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Assign(void * jarg1, void * jarg2) {
69053   void * jresult ;
69054   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69055   Dali::Toolkit::ItemRange *arg2 = 0 ;
69056   Dali::Toolkit::ItemRange *result = 0 ;
69057
69058   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69059   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69060   if (!arg2) {
69061     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69062     return 0;
69063   }
69064   {
69065     try {
69066       result = (Dali::Toolkit::ItemRange *) &(arg1)->operator =((Dali::Toolkit::ItemRange const &)*arg2);
69067     } catch (std::out_of_range& e) {
69068       {
69069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69070       };
69071     } catch (std::exception& e) {
69072       {
69073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69074       };
69075     } catch (Dali::DaliException e) {
69076       {
69077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69078       };
69079     } catch (...) {
69080       {
69081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69082       };
69083     }
69084   }
69085
69086   jresult = (void *)result;
69087   return jresult;
69088 }
69089
69090
69091 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_Within(void * jarg1, unsigned int jarg2) {
69092   unsigned int jresult ;
69093   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69094   unsigned int arg2 ;
69095   bool result;
69096
69097   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69098   arg2 = (unsigned int)jarg2;
69099   {
69100     try {
69101       result = (bool)(arg1)->Within(arg2);
69102     } catch (std::out_of_range& e) {
69103       {
69104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69105       };
69106     } catch (std::exception& e) {
69107       {
69108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69109       };
69110     } catch (Dali::DaliException e) {
69111       {
69112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69113       };
69114     } catch (...) {
69115       {
69116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69117       };
69118     }
69119   }
69120
69121   jresult = result;
69122   return jresult;
69123 }
69124
69125
69126 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemRange_Intersection(void * jarg1, void * jarg2) {
69127   void * jresult ;
69128   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69129   Dali::Toolkit::ItemRange *arg2 = 0 ;
69130   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69131
69132   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69133   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
69134   if (!arg2) {
69135     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange const & type is null", 0);
69136     return 0;
69137   }
69138   {
69139     try {
69140       result = (arg1)->Intersection((Dali::Toolkit::ItemRange const &)*arg2);
69141     } catch (std::out_of_range& e) {
69142       {
69143         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69144       };
69145     } catch (std::exception& e) {
69146       {
69147         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69148       };
69149     } catch (Dali::DaliException e) {
69150       {
69151         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69152       };
69153     } catch (...) {
69154       {
69155         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69156       };
69157     }
69158   }
69159
69160   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69161   return jresult;
69162 }
69163
69164
69165 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_begin_set(void * jarg1, unsigned int jarg2) {
69166   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69167   unsigned int arg2 ;
69168
69169   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69170   arg2 = (unsigned int)jarg2;
69171   if (arg1) (arg1)->begin = arg2;
69172 }
69173
69174
69175 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_begin_get(void * jarg1) {
69176   unsigned int jresult ;
69177   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69178   unsigned int result;
69179
69180   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69181   result = (unsigned int) ((arg1)->begin);
69182   jresult = result;
69183   return jresult;
69184 }
69185
69186
69187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemRange_end_set(void * jarg1, unsigned int jarg2) {
69188   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69189   unsigned int arg2 ;
69190
69191   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69192   arg2 = (unsigned int)jarg2;
69193   if (arg1) (arg1)->end = arg2;
69194 }
69195
69196
69197 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemRange_end_get(void * jarg1) {
69198   unsigned int jresult ;
69199   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69200   unsigned int result;
69201
69202   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69203   result = (unsigned int) ((arg1)->end);
69204   jresult = result;
69205   return jresult;
69206 }
69207
69208
69209 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemRange(void * jarg1) {
69210   Dali::Toolkit::ItemRange *arg1 = (Dali::Toolkit::ItemRange *) 0 ;
69211
69212   arg1 = (Dali::Toolkit::ItemRange *)jarg1;
69213   {
69214     try {
69215       delete arg1;
69216     } catch (std::out_of_range& e) {
69217       {
69218         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69219       };
69220     } catch (std::exception& e) {
69221       {
69222         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69223       };
69224     } catch (Dali::DaliException e) {
69225       {
69226         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69227       };
69228     } catch (...) {
69229       {
69230         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69231       };
69232     }
69233   }
69234
69235 }
69236
69237
69238 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemLayout(void * jarg1) {
69239   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69240
69241   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69242   {
69243     try {
69244       delete arg1;
69245     } catch (std::out_of_range& e) {
69246       {
69247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69248       };
69249     } catch (std::exception& e) {
69250       {
69251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69252       };
69253     } catch (Dali::DaliException e) {
69254       {
69255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69256       };
69257     } catch (...) {
69258       {
69259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69260       };
69261     }
69262   }
69263
69264 }
69265
69266
69267 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetOrientation(void * jarg1, int jarg2) {
69268   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69269   Dali::Toolkit::ControlOrientation::Type arg2 ;
69270
69271   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69272   arg2 = (Dali::Toolkit::ControlOrientation::Type)jarg2;
69273   {
69274     try {
69275       (arg1)->SetOrientation(arg2);
69276     } catch (std::out_of_range& e) {
69277       {
69278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69279       };
69280     } catch (std::exception& e) {
69281       {
69282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69283       };
69284     } catch (Dali::DaliException e) {
69285       {
69286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69287       };
69288     } catch (...) {
69289       {
69290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69291       };
69292     }
69293   }
69294
69295 }
69296
69297
69298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetOrientation(void * jarg1) {
69299   int jresult ;
69300   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69301   Dali::Toolkit::ControlOrientation::Type result;
69302
69303   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69304   {
69305     try {
69306       result = (Dali::Toolkit::ControlOrientation::Type)((Dali::Toolkit::ItemLayout const *)arg1)->GetOrientation();
69307     } catch (std::out_of_range& e) {
69308       {
69309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69310       };
69311     } catch (std::exception& e) {
69312       {
69313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69314       };
69315     } catch (Dali::DaliException e) {
69316       {
69317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69318       };
69319     } catch (...) {
69320       {
69321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69322       };
69323     }
69324   }
69325
69326   jresult = (int)result;
69327   return jresult;
69328 }
69329
69330
69331 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetLayoutProperties(void * jarg1, void * jarg2) {
69332   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69333   Dali::Property::Map *arg2 = 0 ;
69334
69335   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69336   arg2 = (Dali::Property::Map *)jarg2;
69337   if (!arg2) {
69338     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
69339     return ;
69340   }
69341   {
69342     try {
69343       (arg1)->SetLayoutProperties((Dali::Property::Map const &)*arg2);
69344     } catch (std::out_of_range& e) {
69345       {
69346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69347       };
69348     } catch (std::exception& e) {
69349       {
69350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69351       };
69352     } catch (Dali::DaliException e) {
69353       {
69354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69355       };
69356     } catch (...) {
69357       {
69358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69359       };
69360     }
69361   }
69362
69363 }
69364
69365
69366 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetLayoutProperties(void * jarg1) {
69367   void * jresult ;
69368   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69369   Dali::Property::Map result;
69370
69371   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69372   {
69373     try {
69374       result = (arg1)->GetLayoutProperties();
69375     } catch (std::out_of_range& e) {
69376       {
69377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69378       };
69379     } catch (std::exception& e) {
69380       {
69381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69382       };
69383     } catch (Dali::DaliException e) {
69384       {
69385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69386       };
69387     } catch (...) {
69388       {
69389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69390       };
69391     }
69392   }
69393
69394   jresult = new Dali::Property::Map((const Dali::Property::Map &)result);
69395   return jresult;
69396 }
69397
69398
69399 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69400   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69401   unsigned int arg2 ;
69402   Dali::Vector3 *arg3 = 0 ;
69403   Dali::Vector3 *arg4 = 0 ;
69404
69405   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69406   arg2 = (unsigned int)jarg2;
69407   arg3 = (Dali::Vector3 *)jarg3;
69408   if (!arg3) {
69409     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69410     return ;
69411   }
69412   arg4 = (Dali::Vector3 *)jarg4;
69413   if (!arg4) {
69414     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69415     return ;
69416   }
69417   {
69418     try {
69419       ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69420     } catch (std::out_of_range& e) {
69421       {
69422         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69423       };
69424     } catch (std::exception& e) {
69425       {
69426         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69427       };
69428     } catch (Dali::DaliException e) {
69429       {
69430         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69431       };
69432     } catch (...) {
69433       {
69434         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69435       };
69436     }
69437   }
69438
69439 }
69440
69441
69442 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_SetItemSize(void * jarg1, void * jarg2) {
69443   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69444   Dali::Vector3 *arg2 = 0 ;
69445
69446   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69447   arg2 = (Dali::Vector3 *)jarg2;
69448   if (!arg2) {
69449     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69450     return ;
69451   }
69452   {
69453     try {
69454       (arg1)->SetItemSize((Dali::Vector3 const &)*arg2);
69455     } catch (std::out_of_range& e) {
69456       {
69457         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69458       };
69459     } catch (std::exception& e) {
69460       {
69461         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69462       };
69463     } catch (Dali::DaliException e) {
69464       {
69465         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69466       };
69467     } catch (...) {
69468       {
69469         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69470       };
69471     }
69472   }
69473
69474 }
69475
69476
69477 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMinimumLayoutPosition(void * jarg1, unsigned int jarg2, void * jarg3) {
69478   float jresult ;
69479   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69480   unsigned int arg2 ;
69481   Dali::Vector3 arg3 ;
69482   Dali::Vector3 *argp3 ;
69483   float result;
69484
69485   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69486   arg2 = (unsigned int)jarg2;
69487   argp3 = (Dali::Vector3 *)jarg3;
69488   if (!argp3) {
69489     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69490     return 0;
69491   }
69492   arg3 = *argp3;
69493   {
69494     try {
69495       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMinimumLayoutPosition(arg2,arg3);
69496     } catch (std::out_of_range& e) {
69497       {
69498         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69499       };
69500     } catch (std::exception& e) {
69501       {
69502         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69503       };
69504     } catch (Dali::DaliException e) {
69505       {
69506         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69507       };
69508     } catch (...) {
69509       {
69510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69511       };
69512     }
69513   }
69514
69515   jresult = result;
69516   return jresult;
69517 }
69518
69519
69520 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestAnchorPosition(void * jarg1, float jarg2) {
69521   float jresult ;
69522   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69523   float arg2 ;
69524   float result;
69525
69526   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69527   arg2 = (float)jarg2;
69528   {
69529     try {
69530       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetClosestAnchorPosition(arg2);
69531     } catch (std::out_of_range& e) {
69532       {
69533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69534       };
69535     } catch (std::exception& e) {
69536       {
69537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69538       };
69539     } catch (Dali::DaliException e) {
69540       {
69541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69542       };
69543     } catch (...) {
69544       {
69545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69546       };
69547     }
69548   }
69549
69550   jresult = result;
69551   return jresult;
69552 }
69553
69554
69555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemScrollToPosition(void * jarg1, unsigned int jarg2) {
69556   float jresult ;
69557   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69558   unsigned int arg2 ;
69559   float result;
69560
69561   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69562   arg2 = (unsigned int)jarg2;
69563   {
69564     try {
69565       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemScrollToPosition(arg2);
69566     } catch (std::out_of_range& e) {
69567       {
69568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69569       };
69570     } catch (std::exception& e) {
69571       {
69572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69573       };
69574     } catch (Dali::DaliException e) {
69575       {
69576         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69577       };
69578     } catch (...) {
69579       {
69580         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69581       };
69582     }
69583   }
69584
69585   jresult = result;
69586   return jresult;
69587 }
69588
69589
69590 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemsWithinArea(void * jarg1, float jarg2, void * jarg3) {
69591   void * jresult ;
69592   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69593   float arg2 ;
69594   Dali::Vector3 arg3 ;
69595   Dali::Vector3 *argp3 ;
69596   SwigValueWrapper< Dali::Toolkit::ItemRange > result;
69597
69598   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69599   arg2 = (float)jarg2;
69600   argp3 = (Dali::Vector3 *)jarg3;
69601   if (!argp3) {
69602     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69603     return 0;
69604   }
69605   arg3 = *argp3;
69606   {
69607     try {
69608       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemsWithinArea(arg2,arg3);
69609     } catch (std::out_of_range& e) {
69610       {
69611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69612       };
69613     } catch (std::exception& e) {
69614       {
69615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69616       };
69617     } catch (Dali::DaliException e) {
69618       {
69619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69620       };
69621     } catch (...) {
69622       {
69623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69624       };
69625     }
69626   }
69627
69628   jresult = new Dali::Toolkit::ItemRange((const Dali::Toolkit::ItemRange &)result);
69629   return jresult;
69630 }
69631
69632
69633 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetClosestOnScreenLayoutPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
69634   float jresult ;
69635   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69636   int arg2 ;
69637   float arg3 ;
69638   Dali::Vector3 *arg4 = 0 ;
69639   float result;
69640
69641   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69642   arg2 = (int)jarg2;
69643   arg3 = (float)jarg3;
69644   arg4 = (Dali::Vector3 *)jarg4;
69645   if (!arg4) {
69646     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69647     return 0;
69648   }
69649   {
69650     try {
69651       result = (float)(arg1)->GetClosestOnScreenLayoutPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
69652     } catch (std::out_of_range& e) {
69653       {
69654         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69655       };
69656     } catch (std::exception& e) {
69657       {
69658         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69659       };
69660     } catch (Dali::DaliException e) {
69661       {
69662         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69663       };
69664     } catch (...) {
69665       {
69666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69667       };
69668     }
69669   }
69670
69671   jresult = result;
69672   return jresult;
69673 }
69674
69675
69676 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemLayout_GetReserveItemCount(void * jarg1, void * jarg2) {
69677   unsigned int jresult ;
69678   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69679   Dali::Vector3 arg2 ;
69680   Dali::Vector3 *argp2 ;
69681   unsigned int result;
69682
69683   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69684   argp2 = (Dali::Vector3 *)jarg2;
69685   if (!argp2) {
69686     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
69687     return 0;
69688   }
69689   arg2 = *argp2;
69690   {
69691     try {
69692       result = (unsigned int)((Dali::Toolkit::ItemLayout const *)arg1)->GetReserveItemCount(arg2);
69693     } catch (std::out_of_range& e) {
69694       {
69695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69696       };
69697     } catch (std::exception& e) {
69698       {
69699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69700       };
69701     } catch (Dali::DaliException e) {
69702       {
69703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69704       };
69705     } catch (...) {
69706       {
69707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69708       };
69709     }
69710   }
69711
69712   jresult = result;
69713   return jresult;
69714 }
69715
69716
69717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_GetDefaultItemSize(void * jarg1, unsigned int jarg2, void * jarg3, void * jarg4) {
69718   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69719   unsigned int arg2 ;
69720   Dali::Vector3 *arg3 = 0 ;
69721   Dali::Vector3 *arg4 = 0 ;
69722
69723   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69724   arg2 = (unsigned int)jarg2;
69725   arg3 = (Dali::Vector3 *)jarg3;
69726   if (!arg3) {
69727     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69728     return ;
69729   }
69730   arg4 = (Dali::Vector3 *)jarg4;
69731   if (!arg4) {
69732     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
69733     return ;
69734   }
69735   {
69736     try {
69737       ((Dali::Toolkit::ItemLayout const *)arg1)->GetDefaultItemSize(arg2,(Dali::Vector3 const &)*arg3,*arg4);
69738     } catch (std::out_of_range& e) {
69739       {
69740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69741       };
69742     } catch (std::exception& e) {
69743       {
69744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
69745       };
69746     } catch (Dali::DaliException e) {
69747       {
69748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
69749       };
69750     } catch (...) {
69751       {
69752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
69753       };
69754     }
69755   }
69756
69757 }
69758
69759
69760 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollDirection(void * jarg1) {
69761   void * jresult ;
69762   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69763   Dali::Degree result;
69764
69765   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69766   {
69767     try {
69768       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollDirection();
69769     } catch (std::out_of_range& e) {
69770       {
69771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69772       };
69773     } catch (std::exception& e) {
69774       {
69775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69776       };
69777     } catch (Dali::DaliException e) {
69778       {
69779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69780       };
69781     } catch (...) {
69782       {
69783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69784       };
69785     }
69786   }
69787
69788   jresult = new Dali::Degree((const Dali::Degree &)result);
69789   return jresult;
69790 }
69791
69792
69793 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetScrollSpeedFactor(void * jarg1) {
69794   float jresult ;
69795   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69796   float result;
69797
69798   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69799   {
69800     try {
69801       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetScrollSpeedFactor();
69802     } catch (std::out_of_range& e) {
69803       {
69804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69805       };
69806     } catch (std::exception& e) {
69807       {
69808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69809       };
69810     } catch (Dali::DaliException e) {
69811       {
69812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69813       };
69814     } catch (...) {
69815       {
69816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69817       };
69818     }
69819   }
69820
69821   jresult = result;
69822   return jresult;
69823 }
69824
69825
69826 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetMaximumSwipeSpeed(void * jarg1) {
69827   float jresult ;
69828   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69829   float result;
69830
69831   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69832   {
69833     try {
69834       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetMaximumSwipeSpeed();
69835     } catch (std::out_of_range& e) {
69836       {
69837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69838       };
69839     } catch (std::exception& e) {
69840       {
69841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69842       };
69843     } catch (Dali::DaliException e) {
69844       {
69845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69846       };
69847     } catch (...) {
69848       {
69849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69850       };
69851     }
69852   }
69853
69854   jresult = result;
69855   return jresult;
69856 }
69857
69858
69859 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemFlickAnimationDuration(void * jarg1) {
69860   float jresult ;
69861   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69862   float result;
69863
69864   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69865   {
69866     try {
69867       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetItemFlickAnimationDuration();
69868     } catch (std::out_of_range& e) {
69869       {
69870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69871       };
69872     } catch (std::exception& e) {
69873       {
69874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69875       };
69876     } catch (Dali::DaliException e) {
69877       {
69878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69879       };
69880     } catch (...) {
69881       {
69882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69883       };
69884     }
69885   }
69886
69887   jresult = result;
69888   return jresult;
69889 }
69890
69891
69892 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemLayout_GetNextFocusItemID(void * jarg1, int jarg2, int jarg3, int jarg4, unsigned int jarg5) {
69893   int jresult ;
69894   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69895   int arg2 ;
69896   int arg3 ;
69897   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
69898   bool arg5 ;
69899   int result;
69900
69901   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69902   arg2 = (int)jarg2;
69903   arg3 = (int)jarg3;
69904   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
69905   arg5 = jarg5 ? true : false;
69906   {
69907     try {
69908       result = (int)(arg1)->GetNextFocusItemID(arg2,arg3,arg4,arg5);
69909     } catch (std::out_of_range& e) {
69910       {
69911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69912       };
69913     } catch (std::exception& e) {
69914       {
69915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69916       };
69917     } catch (Dali::DaliException e) {
69918       {
69919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69920       };
69921     } catch (...) {
69922       {
69923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69924       };
69925     }
69926   }
69927
69928   jresult = result;
69929   return jresult;
69930 }
69931
69932
69933 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemLayout_GetFlickSpeedFactor(void * jarg1) {
69934   float jresult ;
69935   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69936   float result;
69937
69938   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69939   {
69940     try {
69941       result = (float)((Dali::Toolkit::ItemLayout const *)arg1)->GetFlickSpeedFactor();
69942     } catch (std::out_of_range& e) {
69943       {
69944         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
69945       };
69946     } catch (std::exception& e) {
69947       {
69948         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
69949       };
69950     } catch (Dali::DaliException e) {
69951       {
69952         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
69953       };
69954     } catch (...) {
69955       {
69956         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
69957       };
69958     }
69959   }
69960
69961   jresult = result;
69962   return jresult;
69963 }
69964
69965
69966 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemLayout_ApplyConstraints(void * jarg1, void * jarg2, int jarg3, void * jarg4, void * jarg5) {
69967   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
69968   Dali::Actor *arg2 = 0 ;
69969   int arg3 ;
69970   Dali::Vector3 *arg4 = 0 ;
69971   Dali::Actor *arg5 = 0 ;
69972
69973   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
69974   arg2 = (Dali::Actor *)jarg2;
69975   if (!arg2) {
69976     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
69977     return ;
69978   }
69979   arg3 = (int)jarg3;
69980   arg4 = (Dali::Vector3 *)jarg4;
69981   if (!arg4) {
69982     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
69983     return ;
69984   }
69985   arg5 = (Dali::Actor *)jarg5;
69986   if (!arg5) {
69987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
69988     return ;
69989   }
69990   {
69991     try {
69992       (arg1)->ApplyConstraints(*arg2,arg3,(Dali::Vector3 const &)*arg4,(Dali::Actor const &)*arg5);
69993     } catch (std::out_of_range& e) {
69994       {
69995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
69996       };
69997     } catch (std::exception& e) {
69998       {
69999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70000       };
70001     } catch (Dali::DaliException e) {
70002       {
70003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70004       };
70005     } catch (...) {
70006       {
70007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70008       };
70009     }
70010   }
70011
70012 }
70013
70014
70015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemLayout_GetItemPosition(void * jarg1, int jarg2, float jarg3, void * jarg4) {
70016   void * jresult ;
70017   Dali::Toolkit::ItemLayout *arg1 = (Dali::Toolkit::ItemLayout *) 0 ;
70018   int arg2 ;
70019   float arg3 ;
70020   Dali::Vector3 *arg4 = 0 ;
70021   Dali::Vector3 result;
70022
70023   arg1 = (Dali::Toolkit::ItemLayout *)jarg1;
70024   arg2 = (int)jarg2;
70025   arg3 = (float)jarg3;
70026   arg4 = (Dali::Vector3 *)jarg4;
70027   if (!arg4) {
70028     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
70029     return 0;
70030   }
70031   {
70032     try {
70033       result = ((Dali::Toolkit::ItemLayout const *)arg1)->GetItemPosition(arg2,arg3,(Dali::Vector3 const &)*arg4);
70034     } catch (std::out_of_range& e) {
70035       {
70036         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70037       };
70038     } catch (std::exception& e) {
70039       {
70040         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70041       };
70042     } catch (Dali::DaliException e) {
70043       {
70044         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70045       };
70046     } catch (...) {
70047       {
70048         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70049       };
70050     }
70051   }
70052
70053   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
70054   return jresult;
70055 }
70056
70057
70058 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_NewItemLayout(int jarg1) {
70059   void * jresult ;
70060   Dali::Toolkit::DefaultItemLayout::Type arg1 ;
70061   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70062
70063   arg1 = (Dali::Toolkit::DefaultItemLayout::Type)jarg1;
70064   {
70065     try {
70066       result = Dali::Toolkit::DefaultItemLayout::New(arg1);
70067     } catch (std::out_of_range& e) {
70068       {
70069         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70070       };
70071     } catch (std::exception& e) {
70072       {
70073         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70074       };
70075     } catch (Dali::DaliException e) {
70076       {
70077         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70078       };
70079     } catch (...) {
70080       {
70081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70082       };
70083     }
70084   }
70085
70086   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70087   return jresult;
70088 }
70089
70090
70091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemFactory(void * jarg1) {
70092   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70093
70094   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70095   {
70096     try {
70097       delete arg1;
70098     } catch (std::out_of_range& e) {
70099       {
70100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70101       };
70102     } catch (std::exception& e) {
70103       {
70104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70105       };
70106     } catch (Dali::DaliException e) {
70107       {
70108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70109       };
70110     } catch (...) {
70111       {
70112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70113       };
70114     }
70115   }
70116
70117 }
70118
70119
70120 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemFactory_GetNumberOfItems(void * jarg1) {
70121   unsigned int jresult ;
70122   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70123   unsigned int result;
70124
70125   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70126   {
70127     try {
70128       result = (unsigned int)(arg1)->GetNumberOfItems();
70129     } catch (std::out_of_range& e) {
70130       {
70131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70132       };
70133     } catch (std::exception& e) {
70134       {
70135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70136       };
70137     } catch (Dali::DaliException e) {
70138       {
70139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70140       };
70141     } catch (...) {
70142       {
70143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70144       };
70145     }
70146   }
70147
70148   jresult = result;
70149   return jresult;
70150 }
70151
70152
70153 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemFactory_NewItem(void * jarg1, unsigned int jarg2) {
70154   void * jresult ;
70155   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70156   unsigned int arg2 ;
70157   Dali::Actor result;
70158
70159   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70160   arg2 = (unsigned int)jarg2;
70161   {
70162     try {
70163       result = (arg1)->NewItem(arg2);
70164     } catch (std::out_of_range& e) {
70165       {
70166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70167       };
70168     } catch (std::exception& e) {
70169       {
70170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70171       };
70172     } catch (Dali::DaliException e) {
70173       {
70174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70175       };
70176     } catch (...) {
70177       {
70178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70179       };
70180     }
70181   }
70182
70183   jresult = new Dali::Actor((const Dali::Actor &)result);
70184   return jresult;
70185 }
70186
70187
70188 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleased(void * jarg1, unsigned int jarg2, void * jarg3) {
70189   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70190   unsigned int arg2 ;
70191   Dali::Actor arg3 ;
70192   Dali::Actor *argp3 ;
70193
70194   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70195   arg2 = (unsigned int)jarg2;
70196   argp3 = (Dali::Actor *)jarg3;
70197   if (!argp3) {
70198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70199     return ;
70200   }
70201   arg3 = *argp3;
70202   {
70203     try {
70204       (arg1)->ItemReleased(arg2,arg3);
70205     } catch (std::out_of_range& e) {
70206       {
70207         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70208       };
70209     } catch (std::exception& e) {
70210       {
70211         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70212       };
70213     } catch (Dali::DaliException e) {
70214       {
70215         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70216       };
70217     } catch (...) {
70218       {
70219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70220       };
70221     }
70222   }
70223
70224 }
70225
70226
70227 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemFactory_ItemReleasedSwigExplicitItemFactory(void * jarg1, unsigned int jarg2, void * jarg3) {
70228   Dali::Toolkit::ItemFactory *arg1 = (Dali::Toolkit::ItemFactory *) 0 ;
70229   unsigned int arg2 ;
70230   Dali::Actor arg3 ;
70231   Dali::Actor *argp3 ;
70232
70233   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70234   arg2 = (unsigned int)jarg2;
70235   argp3 = (Dali::Actor *)jarg3;
70236   if (!argp3) {
70237     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
70238     return ;
70239   }
70240   arg3 = *argp3;
70241   {
70242     try {
70243       (arg1)->Dali::Toolkit::ItemFactory::ItemReleased(arg2,arg3);
70244     } catch (std::out_of_range& e) {
70245       {
70246         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70247       };
70248     } catch (std::exception& e) {
70249       {
70250         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70251       };
70252     } catch (Dali::DaliException e) {
70253       {
70254         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70255       };
70256     } catch (...) {
70257       {
70258         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70259       };
70260     }
70261   }
70262
70263 }
70264
70265
70266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemFactory() {
70267   void * jresult ;
70268   Dali::Toolkit::ItemFactory *result = 0 ;
70269
70270   {
70271     try {
70272       result = (Dali::Toolkit::ItemFactory *)new SwigDirector_ItemFactory();
70273     } catch (std::out_of_range& e) {
70274       {
70275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70276       };
70277     } catch (std::exception& e) {
70278       {
70279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70280       };
70281     } catch (Dali::DaliException e) {
70282       {
70283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70284       };
70285     } catch (...) {
70286       {
70287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70288       };
70289     }
70290   }
70291
70292   jresult = (void *)result;
70293   return jresult;
70294 }
70295
70296
70297 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) {
70298   Dali::Toolkit::ItemFactory *obj = (Dali::Toolkit::ItemFactory *)objarg;
70299   SwigDirector_ItemFactory *director = dynamic_cast<SwigDirector_ItemFactory *>(obj);
70300   if (director) {
70301     director->swig_connect_director(callback0, callback1, callback2);
70302   }
70303 }
70304
70305
70306 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_SPEED_get() {
70307   int jresult ;
70308   int result;
70309
70310   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_SPEED;
70311   jresult = (int)result;
70312   return jresult;
70313 }
70314
70315
70316 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_MINIMUM_SWIPE_DISTANCE_get() {
70317   int jresult ;
70318   int result;
70319
70320   result = (int)Dali::Toolkit::ItemView::Property::MINIMUM_SWIPE_DISTANCE;
70321   jresult = (int)result;
70322   return jresult;
70323 }
70324
70325
70326 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
70327   int jresult ;
70328   int result;
70329
70330   result = (int)Dali::Toolkit::ItemView::Property::WHEEL_SCROLL_DISTANCE_STEP;
70331   jresult = (int)result;
70332   return jresult;
70333 }
70334
70335
70336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SNAP_TO_ITEM_ENABLED_get() {
70337   int jresult ;
70338   int result;
70339
70340   result = (int)Dali::Toolkit::ItemView::Property::SNAP_TO_ITEM_ENABLED;
70341   jresult = (int)result;
70342   return jresult;
70343 }
70344
70345
70346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_REFRESH_INTERVAL_get() {
70347   int jresult ;
70348   int result;
70349
70350   result = (int)Dali::Toolkit::ItemView::Property::REFRESH_INTERVAL;
70351   jresult = (int)result;
70352   return jresult;
70353 }
70354
70355
70356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_POSITION_get() {
70357   int jresult ;
70358   int result;
70359
70360   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_POSITION;
70361   jresult = (int)result;
70362   return jresult;
70363 }
70364
70365
70366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_SPEED_get() {
70367   int jresult ;
70368   int result;
70369
70370   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_SPEED;
70371   jresult = (int)result;
70372   return jresult;
70373 }
70374
70375
70376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_OVERSHOOT_get() {
70377   int jresult ;
70378   int result;
70379
70380   result = (int)Dali::Toolkit::ItemView::Property::OVERSHOOT;
70381   jresult = (int)result;
70382   return jresult;
70383 }
70384
70385
70386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_DIRECTION_get() {
70387   int jresult ;
70388   int result;
70389
70390   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_DIRECTION;
70391   jresult = (int)result;
70392   return jresult;
70393 }
70394
70395
70396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_LAYOUT_ORIENTATION_get() {
70397   int jresult ;
70398   int result;
70399
70400   result = (int)Dali::Toolkit::ItemView::Property::LAYOUT_ORIENTATION;
70401   jresult = (int)result;
70402   return jresult;
70403 }
70404
70405
70406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemView_Property_SCROLL_CONTENT_SIZE_get() {
70407   int jresult ;
70408   int result;
70409
70410   result = (int)Dali::Toolkit::ItemView::Property::SCROLL_CONTENT_SIZE;
70411   jresult = (int)result;
70412   return jresult;
70413 }
70414
70415
70416 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView_Property() {
70417   void * jresult ;
70418   Dali::Toolkit::ItemView::Property *result = 0 ;
70419
70420   {
70421     try {
70422       result = (Dali::Toolkit::ItemView::Property *)new Dali::Toolkit::ItemView::Property();
70423     } catch (std::out_of_range& e) {
70424       {
70425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70426       };
70427     } catch (std::exception& e) {
70428       {
70429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70430       };
70431     } catch (Dali::DaliException e) {
70432       {
70433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70434       };
70435     } catch (...) {
70436       {
70437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70438       };
70439     }
70440   }
70441
70442   jresult = (void *)result;
70443   return jresult;
70444 }
70445
70446
70447 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView_Property(void * jarg1) {
70448   Dali::Toolkit::ItemView::Property *arg1 = (Dali::Toolkit::ItemView::Property *) 0 ;
70449
70450   arg1 = (Dali::Toolkit::ItemView::Property *)jarg1;
70451   {
70452     try {
70453       delete arg1;
70454     } catch (std::out_of_range& e) {
70455       {
70456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70457       };
70458     } catch (std::exception& e) {
70459       {
70460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70461       };
70462     } catch (Dali::DaliException e) {
70463       {
70464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70465       };
70466     } catch (...) {
70467       {
70468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70469       };
70470     }
70471   }
70472
70473 }
70474
70475
70476 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_0() {
70477   void * jresult ;
70478   Dali::Toolkit::ItemView *result = 0 ;
70479
70480   {
70481     try {
70482       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView();
70483     } catch (std::out_of_range& e) {
70484       {
70485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70486       };
70487     } catch (std::exception& e) {
70488       {
70489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70490       };
70491     } catch (Dali::DaliException e) {
70492       {
70493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70494       };
70495     } catch (...) {
70496       {
70497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70498       };
70499     }
70500   }
70501
70502   jresult = (void *)result;
70503   return jresult;
70504 }
70505
70506
70507 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemView__SWIG_1(void * jarg1) {
70508   void * jresult ;
70509   Dali::Toolkit::ItemView *arg1 = 0 ;
70510   Dali::Toolkit::ItemView *result = 0 ;
70511
70512   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70513   if (!arg1) {
70514     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70515     return 0;
70516   }
70517   {
70518     try {
70519       result = (Dali::Toolkit::ItemView *)new Dali::Toolkit::ItemView((Dali::Toolkit::ItemView const &)*arg1);
70520     } catch (std::out_of_range& e) {
70521       {
70522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70523       };
70524     } catch (std::exception& e) {
70525       {
70526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70527       };
70528     } catch (Dali::DaliException e) {
70529       {
70530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70531       };
70532     } catch (...) {
70533       {
70534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70535       };
70536     }
70537   }
70538
70539   jresult = (void *)result;
70540   return jresult;
70541 }
70542
70543
70544 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_Assign(void * jarg1, void * jarg2) {
70545   void * jresult ;
70546   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70547   Dali::Toolkit::ItemView *arg2 = 0 ;
70548   Dali::Toolkit::ItemView *result = 0 ;
70549
70550   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70551   arg2 = (Dali::Toolkit::ItemView *)jarg2;
70552   if (!arg2) {
70553     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemView const & type is null", 0);
70554     return 0;
70555   }
70556   {
70557     try {
70558       result = (Dali::Toolkit::ItemView *) &(arg1)->operator =((Dali::Toolkit::ItemView const &)*arg2);
70559     } catch (std::out_of_range& e) {
70560       {
70561         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70562       };
70563     } catch (std::exception& e) {
70564       {
70565         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70566       };
70567     } catch (Dali::DaliException e) {
70568       {
70569         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70570       };
70571     } catch (...) {
70572       {
70573         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70574       };
70575     }
70576   }
70577
70578   jresult = (void *)result;
70579   return jresult;
70580 }
70581
70582
70583 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemView(void * jarg1) {
70584   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70585
70586   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70587   {
70588     try {
70589       delete arg1;
70590     } catch (std::out_of_range& e) {
70591       {
70592         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70593       };
70594     } catch (std::exception& e) {
70595       {
70596         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70597       };
70598     } catch (Dali::DaliException e) {
70599       {
70600         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70601       };
70602     } catch (...) {
70603       {
70604         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70605       };
70606     }
70607   }
70608
70609 }
70610
70611
70612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_New(void * jarg1) {
70613   void * jresult ;
70614   Dali::Toolkit::ItemFactory *arg1 = 0 ;
70615   Dali::Toolkit::ItemView result;
70616
70617   arg1 = (Dali::Toolkit::ItemFactory *)jarg1;
70618   if (!arg1) {
70619     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemFactory & type is null", 0);
70620     return 0;
70621   }
70622   {
70623     try {
70624       result = Dali::Toolkit::ItemView::New(*arg1);
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 = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70645   return jresult;
70646 }
70647
70648
70649 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_DownCast(void * jarg1) {
70650   void * jresult ;
70651   Dali::BaseHandle arg1 ;
70652   Dali::BaseHandle *argp1 ;
70653   Dali::Toolkit::ItemView result;
70654
70655   argp1 = (Dali::BaseHandle *)jarg1;
70656   if (!argp1) {
70657     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
70658     return 0;
70659   }
70660   arg1 = *argp1;
70661   {
70662     try {
70663       result = Dali::Toolkit::ItemView::DownCast(arg1);
70664     } catch (std::out_of_range& e) {
70665       {
70666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70667       };
70668     } catch (std::exception& e) {
70669       {
70670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70671       };
70672     } catch (Dali::DaliException e) {
70673       {
70674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70675       };
70676     } catch (...) {
70677       {
70678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70679       };
70680     }
70681   }
70682
70683   jresult = new Dali::Toolkit::ItemView((const Dali::Toolkit::ItemView &)result);
70684   return jresult;
70685 }
70686
70687
70688 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetLayoutCount(void * jarg1) {
70689   unsigned int jresult ;
70690   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70691   unsigned int result;
70692
70693   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70694   {
70695     try {
70696       result = (unsigned int)((Dali::Toolkit::ItemView const *)arg1)->GetLayoutCount();
70697     } catch (std::out_of_range& e) {
70698       {
70699         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70700       };
70701     } catch (std::exception& e) {
70702       {
70703         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70704       };
70705     } catch (Dali::DaliException e) {
70706       {
70707         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70708       };
70709     } catch (...) {
70710       {
70711         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70712       };
70713     }
70714   }
70715
70716   jresult = result;
70717   return jresult;
70718 }
70719
70720
70721 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_AddLayout(void * jarg1, void * jarg2) {
70722   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70723   Dali::Toolkit::ItemLayout *arg2 = 0 ;
70724
70725   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70726   arg2 = (Dali::Toolkit::ItemLayout *)jarg2;
70727   if (!arg2) {
70728     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemLayout & type is null", 0);
70729     return ;
70730   }
70731   {
70732     try {
70733       (arg1)->AddLayout(*arg2);
70734     } catch (std::out_of_range& e) {
70735       {
70736         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70737       };
70738     } catch (std::exception& e) {
70739       {
70740         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70741       };
70742     } catch (Dali::DaliException e) {
70743       {
70744         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70745       };
70746     } catch (...) {
70747       {
70748         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70749       };
70750     }
70751   }
70752
70753 }
70754
70755
70756 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveLayout(void * jarg1, unsigned int jarg2) {
70757   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70758   unsigned int arg2 ;
70759
70760   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70761   arg2 = (unsigned int)jarg2;
70762   {
70763     try {
70764       (arg1)->RemoveLayout(arg2);
70765     } catch (std::out_of_range& e) {
70766       {
70767         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70768       };
70769     } catch (std::exception& e) {
70770       {
70771         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70772       };
70773     } catch (Dali::DaliException e) {
70774       {
70775         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70776       };
70777     } catch (...) {
70778       {
70779         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70780       };
70781     }
70782   }
70783
70784 }
70785
70786
70787 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetLayout(void * jarg1, unsigned int jarg2) {
70788   void * jresult ;
70789   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70790   unsigned int arg2 ;
70791   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70792
70793   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70794   arg2 = (unsigned int)jarg2;
70795   {
70796     try {
70797       result = ((Dali::Toolkit::ItemView const *)arg1)->GetLayout(arg2);
70798     } catch (std::out_of_range& e) {
70799       {
70800         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70801       };
70802     } catch (std::exception& e) {
70803       {
70804         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70805       };
70806     } catch (Dali::DaliException e) {
70807       {
70808         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70809       };
70810     } catch (...) {
70811       {
70812         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70813       };
70814     }
70815   }
70816
70817   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70818   return jresult;
70819 }
70820
70821
70822 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetActiveLayout(void * jarg1) {
70823   void * jresult ;
70824   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70825   SwigValueWrapper< Dali::IntrusivePtr< Dali::Toolkit::ItemLayout > > result;
70826
70827   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70828   {
70829     try {
70830       result = ((Dali::Toolkit::ItemView const *)arg1)->GetActiveLayout();
70831     } catch (std::out_of_range& e) {
70832       {
70833         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70834       };
70835     } catch (std::exception& e) {
70836       {
70837         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70838       };
70839     } catch (Dali::DaliException e) {
70840       {
70841         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70842       };
70843     } catch (...) {
70844       {
70845         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70846       };
70847     }
70848   }
70849
70850   jresult = new Dali::Toolkit::ItemLayoutPtr((const Dali::Toolkit::ItemLayoutPtr &)result);
70851   return jresult;
70852 }
70853
70854
70855 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetCurrentLayoutPosition(void * jarg1, unsigned int jarg2) {
70856   float jresult ;
70857   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70858   Dali::Toolkit::ItemId arg2 ;
70859   float result;
70860
70861   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70862   arg2 = (Dali::Toolkit::ItemId)jarg2;
70863   {
70864     try {
70865       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetCurrentLayoutPosition(arg2);
70866     } catch (std::out_of_range& e) {
70867       {
70868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
70869       };
70870     } catch (std::exception& e) {
70871       {
70872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
70873       };
70874     } catch (Dali::DaliException e) {
70875       {
70876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
70877       };
70878     } catch (...) {
70879       {
70880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
70881       };
70882     }
70883   }
70884
70885   jresult = result;
70886   return jresult;
70887 }
70888
70889
70890 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ActivateLayout(void * jarg1, unsigned int jarg2, void * jarg3, float jarg4) {
70891   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70892   unsigned int arg2 ;
70893   Dali::Vector3 arg3 ;
70894   float arg4 ;
70895   Dali::Vector3 *argp3 ;
70896
70897   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70898   arg2 = (unsigned int)jarg2;
70899   argp3 = (Dali::Vector3 *)jarg3;
70900   if (!argp3) {
70901     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector3", 0);
70902     return ;
70903   }
70904   arg3 = *argp3;
70905   arg4 = (float)jarg4;
70906   {
70907     try {
70908       (arg1)->ActivateLayout(arg2,arg3,arg4);
70909     } catch (std::out_of_range& e) {
70910       {
70911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70912       };
70913     } catch (std::exception& e) {
70914       {
70915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70916       };
70917     } catch (Dali::DaliException e) {
70918       {
70919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70920       };
70921     } catch (...) {
70922       {
70923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70924       };
70925     }
70926   }
70927
70928 }
70929
70930
70931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_DeactivateCurrentLayout(void * jarg1) {
70932   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70933
70934   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70935   {
70936     try {
70937       (arg1)->DeactivateCurrentLayout();
70938     } catch (std::out_of_range& e) {
70939       {
70940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70941       };
70942     } catch (std::exception& e) {
70943       {
70944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70945       };
70946     } catch (Dali::DaliException e) {
70947       {
70948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70949       };
70950     } catch (...) {
70951       {
70952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70953       };
70954     }
70955   }
70956
70957 }
70958
70959
70960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeSpeed(void * jarg1, float jarg2) {
70961   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70962   float arg2 ;
70963
70964   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70965   arg2 = (float)jarg2;
70966   {
70967     try {
70968       (arg1)->SetMinimumSwipeSpeed(arg2);
70969     } catch (std::out_of_range& e) {
70970       {
70971         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
70972       };
70973     } catch (std::exception& e) {
70974       {
70975         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
70976       };
70977     } catch (Dali::DaliException e) {
70978       {
70979         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
70980       };
70981     } catch (...) {
70982       {
70983         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
70984       };
70985     }
70986   }
70987
70988 }
70989
70990
70991 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeSpeed(void * jarg1) {
70992   float jresult ;
70993   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
70994   float result;
70995
70996   arg1 = (Dali::Toolkit::ItemView *)jarg1;
70997   {
70998     try {
70999       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeSpeed();
71000     } catch (std::out_of_range& e) {
71001       {
71002         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71003       };
71004     } catch (std::exception& e) {
71005       {
71006         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71007       };
71008     } catch (Dali::DaliException e) {
71009       {
71010         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71011       };
71012     } catch (...) {
71013       {
71014         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71015       };
71016     }
71017   }
71018
71019   jresult = result;
71020   return jresult;
71021 }
71022
71023
71024 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetMinimumSwipeDistance(void * jarg1, float jarg2) {
71025   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71026   float arg2 ;
71027
71028   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71029   arg2 = (float)jarg2;
71030   {
71031     try {
71032       (arg1)->SetMinimumSwipeDistance(arg2);
71033     } catch (std::out_of_range& e) {
71034       {
71035         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71036       };
71037     } catch (std::exception& e) {
71038       {
71039         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71040       };
71041     } catch (Dali::DaliException e) {
71042       {
71043         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71044       };
71045     } catch (...) {
71046       {
71047         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71048       };
71049     }
71050   }
71051
71052 }
71053
71054
71055 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetMinimumSwipeDistance(void * jarg1) {
71056   float jresult ;
71057   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71058   float result;
71059
71060   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71061   {
71062     try {
71063       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetMinimumSwipeDistance();
71064     } catch (std::out_of_range& e) {
71065       {
71066         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71067       };
71068     } catch (std::exception& e) {
71069       {
71070         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71071       };
71072     } catch (Dali::DaliException e) {
71073       {
71074         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71075       };
71076     } catch (...) {
71077       {
71078         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71079       };
71080     }
71081   }
71082
71083   jresult = result;
71084   return jresult;
71085 }
71086
71087
71088 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetWheelScrollDistanceStep(void * jarg1, float jarg2) {
71089   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71090   float arg2 ;
71091
71092   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71093   arg2 = (float)jarg2;
71094   {
71095     try {
71096       (arg1)->SetWheelScrollDistanceStep(arg2);
71097     } catch (std::out_of_range& e) {
71098       {
71099         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71100       };
71101     } catch (std::exception& e) {
71102       {
71103         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71104       };
71105     } catch (Dali::DaliException e) {
71106       {
71107         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71108       };
71109     } catch (...) {
71110       {
71111         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71112       };
71113     }
71114   }
71115
71116 }
71117
71118
71119 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetWheelScrollDistanceStep(void * jarg1) {
71120   float jresult ;
71121   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71122   float result;
71123
71124   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71125   {
71126     try {
71127       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetWheelScrollDistanceStep();
71128     } catch (std::out_of_range& e) {
71129       {
71130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71131       };
71132     } catch (std::exception& e) {
71133       {
71134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71135       };
71136     } catch (Dali::DaliException e) {
71137       {
71138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71139       };
71140     } catch (...) {
71141       {
71142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71143       };
71144     }
71145   }
71146
71147   jresult = result;
71148   return jresult;
71149 }
71150
71151
71152 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoring(void * jarg1, unsigned int jarg2) {
71153   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71154   bool arg2 ;
71155
71156   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71157   arg2 = jarg2 ? true : false;
71158   {
71159     try {
71160       (arg1)->SetAnchoring(arg2);
71161     } catch (std::out_of_range& e) {
71162       {
71163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71164       };
71165     } catch (std::exception& e) {
71166       {
71167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71168       };
71169     } catch (Dali::DaliException e) {
71170       {
71171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71172       };
71173     } catch (...) {
71174       {
71175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71176       };
71177     }
71178   }
71179
71180 }
71181
71182 //// ========================= end of part 3 =============================
71183
71184 //// ========================== start part 4 ===============================
71185
71186
71187 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoring(void * jarg1) {
71188   unsigned int jresult ;
71189   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71190   bool result;
71191
71192   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71193   {
71194     try {
71195       result = (bool)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoring();
71196     } catch (std::out_of_range& e) {
71197       {
71198         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71199       };
71200     } catch (std::exception& e) {
71201       {
71202         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71203       };
71204     } catch (Dali::DaliException e) {
71205       {
71206         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71207       };
71208     } catch (...) {
71209       {
71210         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71211       };
71212     }
71213   }
71214
71215   jresult = result;
71216   return jresult;
71217 }
71218
71219
71220 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetAnchoringDuration(void * jarg1, float jarg2) {
71221   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71222   float arg2 ;
71223
71224   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71225   arg2 = (float)jarg2;
71226   {
71227     try {
71228       (arg1)->SetAnchoringDuration(arg2);
71229     } catch (std::out_of_range& e) {
71230       {
71231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71232       };
71233     } catch (std::exception& e) {
71234       {
71235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71236       };
71237     } catch (Dali::DaliException e) {
71238       {
71239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71240       };
71241     } catch (...) {
71242       {
71243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71244       };
71245     }
71246   }
71247
71248 }
71249
71250
71251 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetAnchoringDuration(void * jarg1) {
71252   float jresult ;
71253   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71254   float result;
71255
71256   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71257   {
71258     try {
71259       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetAnchoringDuration();
71260     } catch (std::out_of_range& e) {
71261       {
71262         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71263       };
71264     } catch (std::exception& e) {
71265       {
71266         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71267       };
71268     } catch (Dali::DaliException e) {
71269       {
71270         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71271       };
71272     } catch (...) {
71273       {
71274         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71275       };
71276     }
71277   }
71278
71279   jresult = result;
71280   return jresult;
71281 }
71282
71283
71284 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ScrollToItem(void * jarg1, unsigned int jarg2, float jarg3) {
71285   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71286   Dali::Toolkit::ItemId arg2 ;
71287   float arg3 ;
71288
71289   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71290   arg2 = (Dali::Toolkit::ItemId)jarg2;
71291   arg3 = (float)jarg3;
71292   {
71293     try {
71294       (arg1)->ScrollToItem(arg2,arg3);
71295     } catch (std::out_of_range& e) {
71296       {
71297         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71298       };
71299     } catch (std::exception& e) {
71300       {
71301         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71302       };
71303     } catch (Dali::DaliException e) {
71304       {
71305         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71306       };
71307     } catch (...) {
71308       {
71309         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71310       };
71311     }
71312   }
71313
71314 }
71315
71316
71317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetRefreshInterval(void * jarg1, float jarg2) {
71318   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71319   float arg2 ;
71320
71321   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71322   arg2 = (float)jarg2;
71323   {
71324     try {
71325       (arg1)->SetRefreshInterval(arg2);
71326     } catch (std::out_of_range& e) {
71327       {
71328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71329       };
71330     } catch (std::exception& e) {
71331       {
71332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71333       };
71334     } catch (Dali::DaliException e) {
71335       {
71336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71337       };
71338     } catch (...) {
71339       {
71340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71341       };
71342     }
71343   }
71344
71345 }
71346
71347
71348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ItemView_GetRefreshInterval(void * jarg1) {
71349   float jresult ;
71350   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71351   float result;
71352
71353   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71354   {
71355     try {
71356       result = (float)((Dali::Toolkit::ItemView const *)arg1)->GetRefreshInterval();
71357     } catch (std::out_of_range& e) {
71358       {
71359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71360       };
71361     } catch (std::exception& e) {
71362       {
71363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71364       };
71365     } catch (Dali::DaliException e) {
71366       {
71367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71368       };
71369     } catch (...) {
71370       {
71371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71372       };
71373     }
71374   }
71375
71376   jresult = result;
71377   return jresult;
71378 }
71379
71380
71381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_Refresh(void * jarg1) {
71382   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71383
71384   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71385   {
71386     try {
71387       (arg1)->Refresh();
71388     } catch (std::out_of_range& e) {
71389       {
71390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71391       };
71392     } catch (std::exception& e) {
71393       {
71394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71395       };
71396     } catch (Dali::DaliException e) {
71397       {
71398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71399       };
71400     } catch (...) {
71401       {
71402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71403       };
71404     }
71405   }
71406
71407 }
71408
71409
71410 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItem(void * jarg1, unsigned int jarg2) {
71411   void * jresult ;
71412   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71413   Dali::Toolkit::ItemId arg2 ;
71414   Dali::Actor result;
71415
71416   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71417   arg2 = (Dali::Toolkit::ItemId)jarg2;
71418   {
71419     try {
71420       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItem(arg2);
71421     } catch (std::out_of_range& e) {
71422       {
71423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71424       };
71425     } catch (std::exception& e) {
71426       {
71427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71428       };
71429     } catch (Dali::DaliException e) {
71430       {
71431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71432       };
71433     } catch (...) {
71434       {
71435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71436       };
71437     }
71438   }
71439
71440   jresult = new Dali::Actor((const Dali::Actor &)result);
71441   return jresult;
71442 }
71443
71444
71445 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemView_GetItemId(void * jarg1, void * jarg2) {
71446   unsigned int jresult ;
71447   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71448   Dali::Actor arg2 ;
71449   Dali::Actor *argp2 ;
71450   Dali::Toolkit::ItemId result;
71451
71452   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71453   argp2 = (Dali::Actor *)jarg2;
71454   if (!argp2) {
71455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
71456     return 0;
71457   }
71458   arg2 = *argp2;
71459   {
71460     try {
71461       result = (Dali::Toolkit::ItemId)((Dali::Toolkit::ItemView const *)arg1)->GetItemId(arg2);
71462     } catch (std::out_of_range& e) {
71463       {
71464         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71465       };
71466     } catch (std::exception& e) {
71467       {
71468         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71469       };
71470     } catch (Dali::DaliException e) {
71471       {
71472         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71473       };
71474     } catch (...) {
71475       {
71476         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71477       };
71478     }
71479   }
71480
71481   jresult = result;
71482   return jresult;
71483 }
71484
71485
71486 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItem(void * jarg1, void * jarg2, float jarg3) {
71487   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71488   Dali::Toolkit::Item arg2 ;
71489   float arg3 ;
71490   Dali::Toolkit::Item *argp2 ;
71491
71492   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71493   argp2 = (Dali::Toolkit::Item *)jarg2;
71494   if (!argp2) {
71495     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71496     return ;
71497   }
71498   arg2 = *argp2;
71499   arg3 = (float)jarg3;
71500   {
71501     try {
71502       (arg1)->InsertItem(arg2,arg3);
71503     } catch (std::out_of_range& e) {
71504       {
71505         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71506       };
71507     } catch (std::exception& e) {
71508       {
71509         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71510       };
71511     } catch (Dali::DaliException e) {
71512       {
71513         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71514       };
71515     } catch (...) {
71516       {
71517         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71518       };
71519     }
71520   }
71521
71522 }
71523
71524
71525 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_InsertItems(void * jarg1, void * jarg2, float jarg3) {
71526   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71527   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71528   float arg3 ;
71529
71530   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71531   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71532   if (!arg2) {
71533     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71534     return ;
71535   }
71536   arg3 = (float)jarg3;
71537   {
71538     try {
71539       (arg1)->InsertItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71540     } catch (std::out_of_range& e) {
71541       {
71542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71543       };
71544     } catch (std::exception& e) {
71545       {
71546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71547       };
71548     } catch (Dali::DaliException e) {
71549       {
71550         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71551       };
71552     } catch (...) {
71553       {
71554         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71555       };
71556     }
71557   }
71558
71559 }
71560
71561
71562 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItem(void * jarg1, unsigned int jarg2, float jarg3) {
71563   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71564   Dali::Toolkit::ItemId arg2 ;
71565   float arg3 ;
71566
71567   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71568   arg2 = (Dali::Toolkit::ItemId)jarg2;
71569   arg3 = (float)jarg3;
71570   {
71571     try {
71572       (arg1)->RemoveItem(arg2,arg3);
71573     } catch (std::out_of_range& e) {
71574       {
71575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71576       };
71577     } catch (std::exception& e) {
71578       {
71579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71580       };
71581     } catch (Dali::DaliException e) {
71582       {
71583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71584       };
71585     } catch (...) {
71586       {
71587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71588       };
71589     }
71590   }
71591
71592 }
71593
71594
71595 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_RemoveItems(void * jarg1, void * jarg2, float jarg3) {
71596   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71597   Dali::Toolkit::ItemIdContainer *arg2 = 0 ;
71598   float arg3 ;
71599
71600   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71601   arg2 = (Dali::Toolkit::ItemIdContainer *)jarg2;
71602   if (!arg2) {
71603     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemIdContainer const & type is null", 0);
71604     return ;
71605   }
71606   arg3 = (float)jarg3;
71607   {
71608     try {
71609       (arg1)->RemoveItems((Dali::Toolkit::ItemIdContainer const &)*arg2,arg3);
71610     } catch (std::out_of_range& e) {
71611       {
71612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71613       };
71614     } catch (std::exception& e) {
71615       {
71616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71617       };
71618     } catch (Dali::DaliException e) {
71619       {
71620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71621       };
71622     } catch (...) {
71623       {
71624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71625       };
71626     }
71627   }
71628
71629 }
71630
71631
71632 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItem(void * jarg1, void * jarg2, float jarg3) {
71633   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71634   Dali::Toolkit::Item arg2 ;
71635   float arg3 ;
71636   Dali::Toolkit::Item *argp2 ;
71637
71638   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71639   argp2 = (Dali::Toolkit::Item *)jarg2;
71640   if (!argp2) {
71641     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Item", 0);
71642     return ;
71643   }
71644   arg2 = *argp2;
71645   arg3 = (float)jarg3;
71646   {
71647     try {
71648       (arg1)->ReplaceItem(arg2,arg3);
71649     } catch (std::out_of_range& e) {
71650       {
71651         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71652       };
71653     } catch (std::exception& e) {
71654       {
71655         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71656       };
71657     } catch (Dali::DaliException e) {
71658       {
71659         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71660       };
71661     } catch (...) {
71662       {
71663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71664       };
71665     }
71666   }
71667
71668 }
71669
71670
71671 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_ReplaceItems(void * jarg1, void * jarg2, float jarg3) {
71672   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71673   Dali::Toolkit::ItemContainer *arg2 = 0 ;
71674   float arg3 ;
71675
71676   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71677   arg2 = (Dali::Toolkit::ItemContainer *)jarg2;
71678   if (!arg2) {
71679     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemContainer const & type is null", 0);
71680     return ;
71681   }
71682   arg3 = (float)jarg3;
71683   {
71684     try {
71685       (arg1)->ReplaceItems((Dali::Toolkit::ItemContainer const &)*arg2,arg3);
71686     } catch (std::out_of_range& e) {
71687       {
71688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71689       };
71690     } catch (std::exception& e) {
71691       {
71692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71693       };
71694     } catch (Dali::DaliException e) {
71695       {
71696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71697       };
71698     } catch (...) {
71699       {
71700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71701       };
71702     }
71703   }
71704
71705 }
71706
71707
71708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsParentOrigin(void * jarg1, void * jarg2) {
71709   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71710   Dali::Vector3 *arg2 = 0 ;
71711
71712   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71713   arg2 = (Dali::Vector3 *)jarg2;
71714   if (!arg2) {
71715     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71716     return ;
71717   }
71718   {
71719     try {
71720       (arg1)->SetItemsParentOrigin((Dali::Vector3 const &)*arg2);
71721     } catch (std::out_of_range& e) {
71722       {
71723         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71724       };
71725     } catch (std::exception& e) {
71726       {
71727         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71728       };
71729     } catch (Dali::DaliException e) {
71730       {
71731         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71732       };
71733     } catch (...) {
71734       {
71735         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71736       };
71737     }
71738   }
71739
71740 }
71741
71742
71743 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsParentOrigin(void * jarg1) {
71744   void * jresult ;
71745   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71746   Dali::Vector3 result;
71747
71748   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71749   {
71750     try {
71751       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsParentOrigin();
71752     } catch (std::out_of_range& e) {
71753       {
71754         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71755       };
71756     } catch (std::exception& e) {
71757       {
71758         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71759       };
71760     } catch (Dali::DaliException e) {
71761       {
71762         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71763       };
71764     } catch (...) {
71765       {
71766         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71767       };
71768     }
71769   }
71770
71771   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71772   return jresult;
71773 }
71774
71775
71776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_SetItemsAnchorPoint(void * jarg1, void * jarg2) {
71777   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71778   Dali::Vector3 *arg2 = 0 ;
71779
71780   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71781   arg2 = (Dali::Vector3 *)jarg2;
71782   if (!arg2) {
71783     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
71784     return ;
71785   }
71786   {
71787     try {
71788       (arg1)->SetItemsAnchorPoint((Dali::Vector3 const &)*arg2);
71789     } catch (std::out_of_range& e) {
71790       {
71791         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71792       };
71793     } catch (std::exception& e) {
71794       {
71795         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71796       };
71797     } catch (Dali::DaliException e) {
71798       {
71799         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71800       };
71801     } catch (...) {
71802       {
71803         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71804       };
71805     }
71806   }
71807
71808 }
71809
71810
71811 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_GetItemsAnchorPoint(void * jarg1) {
71812   void * jresult ;
71813   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71814   Dali::Vector3 result;
71815
71816   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71817   {
71818     try {
71819       result = ((Dali::Toolkit::ItemView const *)arg1)->GetItemsAnchorPoint();
71820     } catch (std::out_of_range& e) {
71821       {
71822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71823       };
71824     } catch (std::exception& e) {
71825       {
71826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71827       };
71828     } catch (Dali::DaliException e) {
71829       {
71830         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71831       };
71832     } catch (...) {
71833       {
71834         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71835       };
71836     }
71837   }
71838
71839   jresult = new Dali::Vector3((const Dali::Vector3 &)result);
71840   return jresult;
71841 }
71842
71843
71844 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemView_GetItemsRange(void * jarg1, void * jarg2) {
71845   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71846   Dali::Toolkit::ItemRange *arg2 = 0 ;
71847
71848   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71849   arg2 = (Dali::Toolkit::ItemRange *)jarg2;
71850   if (!arg2) {
71851     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ItemRange & type is null", 0);
71852     return ;
71853   }
71854   {
71855     try {
71856       (arg1)->GetItemsRange(*arg2);
71857     } catch (std::out_of_range& e) {
71858       {
71859         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71860       };
71861     } catch (std::exception& e) {
71862       {
71863         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71864       };
71865     } catch (Dali::DaliException e) {
71866       {
71867         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71868       };
71869     } catch (...) {
71870       {
71871         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71872       };
71873     }
71874   }
71875
71876 }
71877
71878
71879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemView_LayoutActivatedSignal(void * jarg1) {
71880   void * jresult ;
71881   Dali::Toolkit::ItemView *arg1 = (Dali::Toolkit::ItemView *) 0 ;
71882   Dali::Toolkit::ItemView::LayoutActivatedSignalType *result = 0 ;
71883
71884   arg1 = (Dali::Toolkit::ItemView *)jarg1;
71885   {
71886     try {
71887       result = (Dali::Toolkit::ItemView::LayoutActivatedSignalType *) &(arg1)->LayoutActivatedSignal();
71888     } catch (std::out_of_range& e) {
71889       {
71890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
71891       };
71892     } catch (std::exception& e) {
71893       {
71894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
71895       };
71896     } catch (Dali::DaliException e) {
71897       {
71898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
71899       };
71900     } catch (...) {
71901       {
71902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
71903       };
71904     }
71905   }
71906
71907   jresult = (void *)result;
71908   return jresult;
71909 }
71910
71911
71912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_MoveActorConstraint(void * jarg1, void * jarg2) {
71913   Dali::Vector3 *arg1 = 0 ;
71914   PropertyInputContainer *arg2 = 0 ;
71915
71916   arg1 = (Dali::Vector3 *)jarg1;
71917   if (!arg1) {
71918     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71919     return ;
71920   }
71921   arg2 = (PropertyInputContainer *)jarg2;
71922   if (!arg2) {
71923     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71924     return ;
71925   }
71926   {
71927     try {
71928       Dali::Toolkit::MoveActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71929     } catch (std::out_of_range& e) {
71930       {
71931         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71932       };
71933     } catch (std::exception& e) {
71934       {
71935         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71936       };
71937     } catch (Dali::DaliException e) {
71938       {
71939         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71940       };
71941     } catch (...) {
71942       {
71943         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71944       };
71945     }
71946   }
71947
71948 }
71949
71950
71951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WrapActorConstraint(void * jarg1, void * jarg2) {
71952   Dali::Vector3 *arg1 = 0 ;
71953   PropertyInputContainer *arg2 = 0 ;
71954
71955   arg1 = (Dali::Vector3 *)jarg1;
71956   if (!arg1) {
71957     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 & type is null", 0);
71958     return ;
71959   }
71960   arg2 = (PropertyInputContainer *)jarg2;
71961   if (!arg2) {
71962     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "PropertyInputContainer const & type is null", 0);
71963     return ;
71964   }
71965   {
71966     try {
71967       Dali::Toolkit::WrapActorConstraint(*arg1,(PropertyInputContainer const &)*arg2);
71968     } catch (std::out_of_range& e) {
71969       {
71970         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
71971       };
71972     } catch (std::exception& e) {
71973       {
71974         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
71975       };
71976     } catch (Dali::DaliException e) {
71977       {
71978         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
71979       };
71980     } catch (...) {
71981       {
71982         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
71983       };
71984     }
71985   }
71986
71987 }
71988
71989
71990 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewEffect() {
71991   void * jresult ;
71992   Dali::Toolkit::ScrollViewEffect *result = 0 ;
71993
71994   {
71995     try {
71996       result = (Dali::Toolkit::ScrollViewEffect *)new Dali::Toolkit::ScrollViewEffect();
71997     } catch (std::out_of_range& e) {
71998       {
71999         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72000       };
72001     } catch (std::exception& e) {
72002       {
72003         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72004       };
72005     } catch (Dali::DaliException e) {
72006       {
72007         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72008       };
72009     } catch (...) {
72010       {
72011         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72012       };
72013     }
72014   }
72015
72016   jresult = (void *)result;
72017   return jresult;
72018 }
72019
72020
72021 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewEffect(void * jarg1) {
72022   Dali::Toolkit::ScrollViewEffect *arg1 = (Dali::Toolkit::ScrollViewEffect *) 0 ;
72023
72024   arg1 = (Dali::Toolkit::ScrollViewEffect *)jarg1;
72025   {
72026     try {
72027       delete arg1;
72028     } catch (std::out_of_range& e) {
72029       {
72030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72031       };
72032     } catch (std::exception& e) {
72033       {
72034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72035       };
72036     } catch (Dali::DaliException e) {
72037       {
72038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72039       };
72040     } catch (...) {
72041       {
72042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72043       };
72044     }
72045   }
72046
72047 }
72048
72049
72050 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_New(void * jarg1, void * jarg2, int jarg3, void * jarg4, unsigned int jarg5) {
72051   void * jresult ;
72052   Dali::Path arg1 ;
72053   Dali::Vector3 *arg2 = 0 ;
72054   Dali::Property::Index arg3 ;
72055   Dali::Vector3 *arg4 = 0 ;
72056   unsigned int arg5 ;
72057   Dali::Path *argp1 ;
72058   Dali::Toolkit::ScrollViewPagePathEffect result;
72059
72060   argp1 = (Dali::Path *)jarg1;
72061   if (!argp1) {
72062     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Path", 0);
72063     return 0;
72064   }
72065   arg1 = *argp1;
72066   arg2 = (Dali::Vector3 *)jarg2;
72067   if (!arg2) {
72068     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72069     return 0;
72070   }
72071   arg3 = (Dali::Property::Index)jarg3;
72072   arg4 = (Dali::Vector3 *)jarg4;
72073   if (!arg4) {
72074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector3 const & type is null", 0);
72075     return 0;
72076   }
72077   arg5 = (unsigned int)jarg5;
72078   {
72079     try {
72080       result = Dali::Toolkit::ScrollViewPagePathEffect::New(arg1,(Dali::Vector3 const &)*arg2,arg3,(Dali::Vector3 const &)*arg4,arg5);
72081     } catch (std::out_of_range& e) {
72082       {
72083         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72084       };
72085     } catch (std::exception& e) {
72086       {
72087         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72088       };
72089     } catch (Dali::DaliException e) {
72090       {
72091         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72092       };
72093     } catch (...) {
72094       {
72095         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72096       };
72097     }
72098   }
72099
72100   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72101   return jresult;
72102 }
72103
72104
72105 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewPagePathEffect() {
72106   void * jresult ;
72107   Dali::Toolkit::ScrollViewPagePathEffect *result = 0 ;
72108
72109   {
72110     try {
72111       result = (Dali::Toolkit::ScrollViewPagePathEffect *)new Dali::Toolkit::ScrollViewPagePathEffect();
72112     } catch (std::out_of_range& e) {
72113       {
72114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72115       };
72116     } catch (std::exception& e) {
72117       {
72118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72119       };
72120     } catch (Dali::DaliException e) {
72121       {
72122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72123       };
72124     } catch (...) {
72125       {
72126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72127       };
72128     }
72129   }
72130
72131   jresult = (void *)result;
72132   return jresult;
72133 }
72134
72135
72136 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_DownCast(void * jarg1) {
72137   void * jresult ;
72138   Dali::BaseHandle arg1 ;
72139   Dali::BaseHandle *argp1 ;
72140   Dali::Toolkit::ScrollViewPagePathEffect result;
72141
72142   argp1 = (Dali::BaseHandle *)jarg1;
72143   if (!argp1) {
72144     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
72145     return 0;
72146   }
72147   arg1 = *argp1;
72148   {
72149     try {
72150       result = Dali::Toolkit::ScrollViewPagePathEffect::DownCast(arg1);
72151     } catch (std::out_of_range& e) {
72152       {
72153         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72154       };
72155     } catch (std::exception& e) {
72156       {
72157         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72158       };
72159     } catch (Dali::DaliException e) {
72160       {
72161         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72162       };
72163     } catch (...) {
72164       {
72165         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72166       };
72167     }
72168   }
72169
72170   jresult = new Dali::Toolkit::ScrollViewPagePathEffect((const Dali::Toolkit::ScrollViewPagePathEffect &)result);
72171   return jresult;
72172 }
72173
72174
72175 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_ApplyToPage(void * jarg1, void * jarg2, unsigned int jarg3) {
72176   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72177   Dali::Actor arg2 ;
72178   unsigned int arg3 ;
72179   Dali::Actor *argp2 ;
72180
72181   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72182   argp2 = (Dali::Actor *)jarg2;
72183   if (!argp2) {
72184     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
72185     return ;
72186   }
72187   arg2 = *argp2;
72188   arg3 = (unsigned int)jarg3;
72189   {
72190     try {
72191       (arg1)->ApplyToPage(arg2,arg3);
72192     } catch (std::out_of_range& e) {
72193       {
72194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72195       };
72196     } catch (std::exception& e) {
72197       {
72198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72199       };
72200     } catch (Dali::DaliException e) {
72201       {
72202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72203       };
72204     } catch (...) {
72205       {
72206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72207       };
72208     }
72209   }
72210
72211 }
72212
72213
72214 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewPagePathEffect(void * jarg1) {
72215   Dali::Toolkit::ScrollViewPagePathEffect *arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *) 0 ;
72216
72217   arg1 = (Dali::Toolkit::ScrollViewPagePathEffect *)jarg1;
72218   {
72219     try {
72220       delete arg1;
72221     } catch (std::out_of_range& e) {
72222       {
72223         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72224       };
72225     } catch (std::exception& e) {
72226       {
72227         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72228       };
72229     } catch (Dali::DaliException e) {
72230       {
72231         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72232       };
72233     } catch (...) {
72234       {
72235         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72236       };
72237     }
72238   }
72239
72240 }
72241
72242
72243 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_x_set(void * jarg1, int jarg2) {
72244   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72245   Dali::Toolkit::ClampState arg2 ;
72246
72247   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72248   arg2 = (Dali::Toolkit::ClampState)jarg2;
72249   if (arg1) (arg1)->x = arg2;
72250 }
72251
72252
72253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_x_get(void * jarg1) {
72254   int jresult ;
72255   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72256   Dali::Toolkit::ClampState result;
72257
72258   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72259   result = (Dali::Toolkit::ClampState) ((arg1)->x);
72260   jresult = (int)result;
72261   return jresult;
72262 }
72263
72264
72265 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ClampState2D_y_set(void * jarg1, int jarg2) {
72266   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72267   Dali::Toolkit::ClampState arg2 ;
72268
72269   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72270   arg2 = (Dali::Toolkit::ClampState)jarg2;
72271   if (arg1) (arg1)->y = arg2;
72272 }
72273
72274
72275 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ClampState2D_y_get(void * jarg1) {
72276   int jresult ;
72277   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72278   Dali::Toolkit::ClampState result;
72279
72280   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72281   result = (Dali::Toolkit::ClampState) ((arg1)->y);
72282   jresult = (int)result;
72283   return jresult;
72284 }
72285
72286
72287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ClampState2D() {
72288   void * jresult ;
72289   Dali::Toolkit::ClampState2D *result = 0 ;
72290
72291   {
72292     try {
72293       result = (Dali::Toolkit::ClampState2D *)new Dali::Toolkit::ClampState2D();
72294     } catch (std::out_of_range& e) {
72295       {
72296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72297       };
72298     } catch (std::exception& e) {
72299       {
72300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72301       };
72302     } catch (Dali::DaliException e) {
72303       {
72304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72305       };
72306     } catch (...) {
72307       {
72308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72309       };
72310     }
72311   }
72312
72313   jresult = (void *)result;
72314   return jresult;
72315 }
72316
72317
72318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ClampState2D(void * jarg1) {
72319   Dali::Toolkit::ClampState2D *arg1 = (Dali::Toolkit::ClampState2D *) 0 ;
72320
72321   arg1 = (Dali::Toolkit::ClampState2D *)jarg1;
72322   {
72323     try {
72324       delete arg1;
72325     } catch (std::out_of_range& e) {
72326       {
72327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72328       };
72329     } catch (std::exception& e) {
72330       {
72331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72332       };
72333     } catch (Dali::DaliException e) {
72334       {
72335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72336       };
72337     } catch (...) {
72338       {
72339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72340       };
72341     }
72342   }
72343
72344 }
72345
72346
72347 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_0(float jarg1, float jarg2, unsigned int jarg3) {
72348   void * jresult ;
72349   float arg1 ;
72350   float arg2 ;
72351   bool arg3 ;
72352   Dali::Toolkit::RulerDomain *result = 0 ;
72353
72354   arg1 = (float)jarg1;
72355   arg2 = (float)jarg2;
72356   arg3 = jarg3 ? true : false;
72357   {
72358     try {
72359       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2,arg3);
72360     } catch (std::out_of_range& e) {
72361       {
72362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72363       };
72364     } catch (std::exception& e) {
72365       {
72366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72367       };
72368     } catch (Dali::DaliException e) {
72369       {
72370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72371       };
72372     } catch (...) {
72373       {
72374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72375       };
72376     }
72377   }
72378
72379   jresult = (void *)result;
72380   return jresult;
72381 }
72382
72383
72384 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerDomain__SWIG_1(float jarg1, float jarg2) {
72385   void * jresult ;
72386   float arg1 ;
72387   float arg2 ;
72388   Dali::Toolkit::RulerDomain *result = 0 ;
72389
72390   arg1 = (float)jarg1;
72391   arg2 = (float)jarg2;
72392   {
72393     try {
72394       result = (Dali::Toolkit::RulerDomain *)new Dali::Toolkit::RulerDomain(arg1,arg2);
72395     } catch (std::out_of_range& e) {
72396       {
72397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72398       };
72399     } catch (std::exception& e) {
72400       {
72401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72402       };
72403     } catch (Dali::DaliException e) {
72404       {
72405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72406       };
72407     } catch (...) {
72408       {
72409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72410       };
72411     }
72412   }
72413
72414   jresult = (void *)result;
72415   return jresult;
72416 }
72417
72418
72419 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_min_set(void * jarg1, float jarg2) {
72420   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72421   float arg2 ;
72422
72423   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72424   arg2 = (float)jarg2;
72425   if (arg1) (arg1)->min = arg2;
72426 }
72427
72428
72429 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_min_get(void * jarg1) {
72430   float jresult ;
72431   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72432   float result;
72433
72434   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72435   result = (float) ((arg1)->min);
72436   jresult = result;
72437   return jresult;
72438 }
72439
72440
72441 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_max_set(void * jarg1, float jarg2) {
72442   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72443   float arg2 ;
72444
72445   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72446   arg2 = (float)jarg2;
72447   if (arg1) (arg1)->max = arg2;
72448 }
72449
72450
72451 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_max_get(void * jarg1) {
72452   float jresult ;
72453   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72454   float result;
72455
72456   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72457   result = (float) ((arg1)->max);
72458   jresult = result;
72459   return jresult;
72460 }
72461
72462
72463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_set(void * jarg1, unsigned int jarg2) {
72464   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72465   bool arg2 ;
72466
72467   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72468   arg2 = jarg2 ? true : false;
72469   if (arg1) (arg1)->enabled = arg2;
72470 }
72471
72472
72473 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerDomain_enabled_get(void * jarg1) {
72474   unsigned int jresult ;
72475   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72476   bool result;
72477
72478   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72479   result = (bool) ((arg1)->enabled);
72480   jresult = result;
72481   return jresult;
72482 }
72483
72484
72485 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
72486   float jresult ;
72487   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72488   float arg2 ;
72489   float arg3 ;
72490   float arg4 ;
72491   float result;
72492
72493   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72494   arg2 = (float)jarg2;
72495   arg3 = (float)jarg3;
72496   arg4 = (float)jarg4;
72497   {
72498     try {
72499       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4);
72500     } catch (std::out_of_range& e) {
72501       {
72502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72503       };
72504     } catch (std::exception& e) {
72505       {
72506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72507       };
72508     } catch (Dali::DaliException e) {
72509       {
72510         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72511       };
72512     } catch (...) {
72513       {
72514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72515       };
72516     }
72517   }
72518
72519   jresult = result;
72520   return jresult;
72521 }
72522
72523
72524 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
72525   float jresult ;
72526   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72527   float arg2 ;
72528   float arg3 ;
72529   float result;
72530
72531   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72532   arg2 = (float)jarg2;
72533   arg3 = (float)jarg3;
72534   {
72535     try {
72536       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3);
72537     } catch (std::out_of_range& e) {
72538       {
72539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72540       };
72541     } catch (std::exception& e) {
72542       {
72543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72544       };
72545     } catch (Dali::DaliException e) {
72546       {
72547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72548       };
72549     } catch (...) {
72550       {
72551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72552       };
72553     }
72554   }
72555
72556   jresult = result;
72557   return jresult;
72558 }
72559
72560
72561 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_2(void * jarg1, float jarg2) {
72562   float jresult ;
72563   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72564   float arg2 ;
72565   float result;
72566
72567   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72568   arg2 = (float)jarg2;
72569   {
72570     try {
72571       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2);
72572     } catch (std::out_of_range& e) {
72573       {
72574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72575       };
72576     } catch (std::exception& e) {
72577       {
72578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72579       };
72580     } catch (Dali::DaliException e) {
72581       {
72582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72583       };
72584     } catch (...) {
72585       {
72586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72587       };
72588     }
72589   }
72590
72591   jresult = result;
72592   return jresult;
72593 }
72594
72595
72596 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
72597   float jresult ;
72598   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72599   float arg2 ;
72600   float arg3 ;
72601   float arg4 ;
72602   Dali::Toolkit::ClampState *arg5 = 0 ;
72603   float result;
72604
72605   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72606   arg2 = (float)jarg2;
72607   arg3 = (float)jarg3;
72608   arg4 = (float)jarg4;
72609   arg5 = (Dali::Toolkit::ClampState *)jarg5;
72610   if (!arg5) {
72611     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
72612     return 0;
72613   }
72614   {
72615     try {
72616       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
72617     } catch (std::out_of_range& e) {
72618       {
72619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72620       };
72621     } catch (std::exception& e) {
72622       {
72623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72624       };
72625     } catch (Dali::DaliException e) {
72626       {
72627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72628       };
72629     } catch (...) {
72630       {
72631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72632       };
72633     }
72634   }
72635
72636   jresult = result;
72637   return jresult;
72638 }
72639
72640
72641 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerDomain_GetSize(void * jarg1) {
72642   float jresult ;
72643   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72644   float result;
72645
72646   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72647   {
72648     try {
72649       result = (float)((Dali::Toolkit::RulerDomain const *)arg1)->GetSize();
72650     } catch (std::out_of_range& e) {
72651       {
72652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72653       };
72654     } catch (std::exception& e) {
72655       {
72656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72657       };
72658     } catch (Dali::DaliException e) {
72659       {
72660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72661       };
72662     } catch (...) {
72663       {
72664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72665       };
72666     }
72667   }
72668
72669   jresult = result;
72670   return jresult;
72671 }
72672
72673
72674 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerDomain(void * jarg1) {
72675   Dali::Toolkit::RulerDomain *arg1 = (Dali::Toolkit::RulerDomain *) 0 ;
72676
72677   arg1 = (Dali::Toolkit::RulerDomain *)jarg1;
72678   {
72679     try {
72680       delete arg1;
72681     } catch (std::out_of_range& e) {
72682       {
72683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72684       };
72685     } catch (std::exception& e) {
72686       {
72687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72688       };
72689     } catch (Dali::DaliException e) {
72690       {
72691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72692       };
72693     } catch (...) {
72694       {
72695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72696       };
72697     }
72698   }
72699
72700 }
72701
72702
72703 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
72704   float jresult ;
72705   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72706   float arg2 ;
72707   float arg3 ;
72708   float result;
72709
72710   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72711   arg2 = (float)jarg2;
72712   arg3 = (float)jarg3;
72713   {
72714     try {
72715       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2,arg3);
72716     } catch (std::out_of_range& e) {
72717       {
72718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72719       };
72720     } catch (std::exception& e) {
72721       {
72722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72723       };
72724     } catch (Dali::DaliException e) {
72725       {
72726         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72727       };
72728     } catch (...) {
72729       {
72730         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72731       };
72732     }
72733   }
72734
72735   jresult = result;
72736   return jresult;
72737 }
72738
72739
72740 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Snap__SWIG_1(void * jarg1, float jarg2) {
72741   float jresult ;
72742   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72743   float arg2 ;
72744   float result;
72745
72746   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72747   arg2 = (float)jarg2;
72748   {
72749     try {
72750       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Snap(arg2);
72751     } catch (std::out_of_range& e) {
72752       {
72753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72754       };
72755     } catch (std::exception& e) {
72756       {
72757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72758       };
72759     } catch (Dali::DaliException e) {
72760       {
72761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72762       };
72763     } catch (...) {
72764       {
72765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72766       };
72767     }
72768   }
72769
72770   jresult = result;
72771   return jresult;
72772 }
72773
72774
72775 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
72776   float jresult ;
72777   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72778   unsigned int arg2 ;
72779   unsigned int *arg3 = 0 ;
72780   bool arg4 ;
72781   float result;
72782
72783   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72784   arg2 = (unsigned int)jarg2;
72785   arg3 = (unsigned int *)jarg3;
72786   arg4 = jarg4 ? true : false;
72787   {
72788     try {
72789       result = (float)((Dali::Toolkit::Ruler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
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 = result;
72810   return jresult;
72811 }
72812
72813
72814 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
72815   unsigned int jresult ;
72816   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72817   float arg2 ;
72818   bool arg3 ;
72819   unsigned int result;
72820
72821   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72822   arg2 = (float)jarg2;
72823   arg3 = jarg3 ? true : false;
72824   {
72825     try {
72826       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetPageFromPosition(arg2,arg3);
72827     } catch (std::out_of_range& e) {
72828       {
72829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72830       };
72831     } catch (std::exception& e) {
72832       {
72833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72834       };
72835     } catch (Dali::DaliException e) {
72836       {
72837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72838       };
72839     } catch (...) {
72840       {
72841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72842       };
72843     }
72844   }
72845
72846   jresult = result;
72847   return jresult;
72848 }
72849
72850
72851 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_GetTotalPages(void * jarg1) {
72852   unsigned int jresult ;
72853   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72854   unsigned int result;
72855
72856   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72857   {
72858     try {
72859       result = (unsigned int)((Dali::Toolkit::Ruler const *)arg1)->GetTotalPages();
72860     } catch (std::out_of_range& e) {
72861       {
72862         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72863       };
72864     } catch (std::exception& e) {
72865       {
72866         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72867       };
72868     } catch (Dali::DaliException e) {
72869       {
72870         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72871       };
72872     } catch (...) {
72873       {
72874         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72875       };
72876     }
72877   }
72878
72879   jresult = result;
72880   return jresult;
72881 }
72882
72883
72884 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Ruler_GetType(void * jarg1) {
72885   int jresult ;
72886   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72887   Dali::Toolkit::Ruler::RulerType result;
72888
72889   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72890   {
72891     try {
72892       result = (Dali::Toolkit::Ruler::RulerType)((Dali::Toolkit::Ruler const *)arg1)->GetType();
72893     } catch (std::out_of_range& e) {
72894       {
72895         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72896       };
72897     } catch (std::exception& e) {
72898       {
72899         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72900       };
72901     } catch (Dali::DaliException e) {
72902       {
72903         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72904       };
72905     } catch (...) {
72906       {
72907         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72908       };
72909     }
72910   }
72911
72912   jresult = (int)result;
72913   return jresult;
72914 }
72915
72916
72917 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Ruler_IsEnabled(void * jarg1) {
72918   unsigned int jresult ;
72919   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72920   bool result;
72921
72922   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72923   {
72924     try {
72925       result = (bool)((Dali::Toolkit::Ruler const *)arg1)->IsEnabled();
72926     } catch (std::out_of_range& e) {
72927       {
72928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
72929       };
72930     } catch (std::exception& e) {
72931       {
72932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
72933       };
72934     } catch (Dali::DaliException e) {
72935       {
72936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
72937       };
72938     } catch (...) {
72939       {
72940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
72941       };
72942     }
72943   }
72944
72945   jresult = result;
72946   return jresult;
72947 }
72948
72949
72950 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Enable(void * jarg1) {
72951   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72952
72953   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72954   {
72955     try {
72956       (arg1)->Enable();
72957     } catch (std::out_of_range& e) {
72958       {
72959         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72960       };
72961     } catch (std::exception& e) {
72962       {
72963         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72964       };
72965     } catch (Dali::DaliException e) {
72966       {
72967         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72968       };
72969     } catch (...) {
72970       {
72971         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
72972       };
72973     }
72974   }
72975
72976 }
72977
72978
72979 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_Disable(void * jarg1) {
72980   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
72981
72982   arg1 = (Dali::Toolkit::Ruler *)jarg1;
72983   {
72984     try {
72985       (arg1)->Disable();
72986     } catch (std::out_of_range& e) {
72987       {
72988         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
72989       };
72990     } catch (std::exception& e) {
72991       {
72992         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
72993       };
72994     } catch (Dali::DaliException e) {
72995       {
72996         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
72997       };
72998     } catch (...) {
72999       {
73000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73001       };
73002     }
73003   }
73004
73005 }
73006
73007
73008 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_SetDomain(void * jarg1, void * jarg2) {
73009   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73010   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
73011   Dali::Toolkit::RulerDomain *argp2 ;
73012
73013   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73014   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
73015   if (!argp2) {
73016     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
73017     return ;
73018   }
73019   arg2 = *argp2;
73020   {
73021     try {
73022       (arg1)->SetDomain(arg2);
73023     } catch (std::out_of_range& e) {
73024       {
73025         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73026       };
73027     } catch (std::exception& e) {
73028       {
73029         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73030       };
73031     } catch (Dali::DaliException e) {
73032       {
73033         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73034       };
73035     } catch (...) {
73036       {
73037         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73038       };
73039     }
73040   }
73041
73042 }
73043
73044
73045 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Ruler_GetDomain(void * jarg1) {
73046   void * jresult ;
73047   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73048   Dali::Toolkit::RulerDomain *result = 0 ;
73049
73050   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73051   {
73052     try {
73053       result = (Dali::Toolkit::RulerDomain *) &((Dali::Toolkit::Ruler const *)arg1)->GetDomain();
73054     } catch (std::out_of_range& e) {
73055       {
73056         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73057       };
73058     } catch (std::exception& e) {
73059       {
73060         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73061       };
73062     } catch (Dali::DaliException e) {
73063       {
73064         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73065       };
73066     } catch (...) {
73067       {
73068         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73069       };
73070     }
73071   }
73072
73073   jresult = (void *)result;
73074   return jresult;
73075 }
73076
73077
73078 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Ruler_DisableDomain(void * jarg1) {
73079   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73080
73081   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73082   {
73083     try {
73084       (arg1)->DisableDomain();
73085     } catch (std::out_of_range& e) {
73086       {
73087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73088       };
73089     } catch (std::exception& e) {
73090       {
73091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73092       };
73093     } catch (Dali::DaliException e) {
73094       {
73095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73096       };
73097     } catch (...) {
73098       {
73099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73100       };
73101     }
73102   }
73103
73104 }
73105
73106
73107 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
73108   float jresult ;
73109   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73110   float arg2 ;
73111   float arg3 ;
73112   float arg4 ;
73113   float result;
73114
73115   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73116   arg2 = (float)jarg2;
73117   arg3 = (float)jarg3;
73118   arg4 = (float)jarg4;
73119   {
73120     try {
73121       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4);
73122     } catch (std::out_of_range& e) {
73123       {
73124         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73125       };
73126     } catch (std::exception& e) {
73127       {
73128         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73129       };
73130     } catch (Dali::DaliException e) {
73131       {
73132         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73133       };
73134     } catch (...) {
73135       {
73136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73137       };
73138     }
73139   }
73140
73141   jresult = result;
73142   return jresult;
73143 }
73144
73145
73146 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
73147   float jresult ;
73148   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73149   float arg2 ;
73150   float arg3 ;
73151   float result;
73152
73153   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73154   arg2 = (float)jarg2;
73155   arg3 = (float)jarg3;
73156   {
73157     try {
73158       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3);
73159     } catch (std::out_of_range& e) {
73160       {
73161         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73162       };
73163     } catch (std::exception& e) {
73164       {
73165         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73166       };
73167     } catch (Dali::DaliException e) {
73168       {
73169         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73170       };
73171     } catch (...) {
73172       {
73173         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73174       };
73175     }
73176   }
73177
73178   jresult = result;
73179   return jresult;
73180 }
73181
73182
73183 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_2(void * jarg1, float jarg2) {
73184   float jresult ;
73185   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73186   float arg2 ;
73187   float result;
73188
73189   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73190   arg2 = (float)jarg2;
73191   {
73192     try {
73193       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2);
73194     } catch (std::out_of_range& e) {
73195       {
73196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73197       };
73198     } catch (std::exception& e) {
73199       {
73200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73201       };
73202     } catch (Dali::DaliException e) {
73203       {
73204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73205       };
73206     } catch (...) {
73207       {
73208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73209       };
73210     }
73211   }
73212
73213   jresult = result;
73214   return jresult;
73215 }
73216
73217
73218 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
73219   float jresult ;
73220   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73221   float arg2 ;
73222   float arg3 ;
73223   float arg4 ;
73224   Dali::Toolkit::ClampState *arg5 = 0 ;
73225   float result;
73226
73227   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73228   arg2 = (float)jarg2;
73229   arg3 = (float)jarg3;
73230   arg4 = (float)jarg4;
73231   arg5 = (Dali::Toolkit::ClampState *)jarg5;
73232   if (!arg5) {
73233     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73234     return 0;
73235   }
73236   {
73237     try {
73238       result = (float)((Dali::Toolkit::Ruler const *)arg1)->Clamp(arg2,arg3,arg4,*arg5);
73239     } catch (std::out_of_range& e) {
73240       {
73241         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73242       };
73243     } catch (std::exception& e) {
73244       {
73245         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73246       };
73247     } catch (Dali::DaliException e) {
73248       {
73249         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73250       };
73251     } catch (...) {
73252       {
73253         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73254       };
73255     }
73256   }
73257
73258   jresult = result;
73259   return jresult;
73260 }
73261
73262
73263 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
73264   float jresult ;
73265   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73266   float arg2 ;
73267   float arg3 ;
73268   float arg4 ;
73269   float arg5 ;
73270   float result;
73271
73272   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73273   arg2 = (float)jarg2;
73274   arg3 = (float)jarg3;
73275   arg4 = (float)jarg4;
73276   arg5 = (float)jarg5;
73277   {
73278     try {
73279       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
73280     } catch (std::out_of_range& e) {
73281       {
73282         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73283       };
73284     } catch (std::exception& e) {
73285       {
73286         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73287       };
73288     } catch (Dali::DaliException e) {
73289       {
73290         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73291       };
73292     } catch (...) {
73293       {
73294         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73295       };
73296     }
73297   }
73298
73299   jresult = result;
73300   return jresult;
73301 }
73302
73303
73304 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
73305   float jresult ;
73306   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73307   float arg2 ;
73308   float arg3 ;
73309   float arg4 ;
73310   float result;
73311
73312   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73313   arg2 = (float)jarg2;
73314   arg3 = (float)jarg3;
73315   arg4 = (float)jarg4;
73316   {
73317     try {
73318       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4);
73319     } catch (std::out_of_range& e) {
73320       {
73321         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73322       };
73323     } catch (std::exception& e) {
73324       {
73325         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73326       };
73327     } catch (Dali::DaliException e) {
73328       {
73329         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73330       };
73331     } catch (...) {
73332       {
73333         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73334       };
73335     }
73336   }
73337
73338   jresult = result;
73339   return jresult;
73340 }
73341
73342
73343 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
73344   float jresult ;
73345   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73346   float arg2 ;
73347   float arg3 ;
73348   float result;
73349
73350   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73351   arg2 = (float)jarg2;
73352   arg3 = (float)jarg3;
73353   {
73354     try {
73355       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
73381   float jresult ;
73382   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73383   float arg2 ;
73384   float result;
73385
73386   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73387   arg2 = (float)jarg2;
73388   {
73389     try {
73390       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2);
73391     } catch (std::out_of_range& e) {
73392       {
73393         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73394       };
73395     } catch (std::exception& e) {
73396       {
73397         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73398       };
73399     } catch (Dali::DaliException e) {
73400       {
73401         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73402       };
73403     } catch (...) {
73404       {
73405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73406       };
73407     }
73408   }
73409
73410   jresult = result;
73411   return jresult;
73412 }
73413
73414
73415 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_Ruler_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
73416   float jresult ;
73417   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
73418   float arg2 ;
73419   float arg3 ;
73420   float arg4 ;
73421   float arg5 ;
73422   Dali::Toolkit::ClampState *arg6 = 0 ;
73423   float result;
73424
73425   arg1 = (Dali::Toolkit::Ruler *)jarg1;
73426   arg2 = (float)jarg2;
73427   arg3 = (float)jarg3;
73428   arg4 = (float)jarg4;
73429   arg5 = (float)jarg5;
73430   arg6 = (Dali::Toolkit::ClampState *)jarg6;
73431   if (!arg6) {
73432     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
73433     return 0;
73434   }
73435   {
73436     try {
73437       result = (float)((Dali::Toolkit::Ruler const *)arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
73438     } catch (std::out_of_range& e) {
73439       {
73440         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73441       };
73442     } catch (std::exception& e) {
73443       {
73444         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73445       };
73446     } catch (Dali::DaliException e) {
73447       {
73448         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73449       };
73450     } catch (...) {
73451       {
73452         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73453       };
73454     }
73455   }
73456
73457   jresult = result;
73458   return jresult;
73459 }
73460
73461
73462 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_DefaultRuler() {
73463   void * jresult ;
73464   Dali::Toolkit::DefaultRuler *result = 0 ;
73465
73466   {
73467     try {
73468       result = (Dali::Toolkit::DefaultRuler *)new Dali::Toolkit::DefaultRuler();
73469     } catch (std::out_of_range& e) {
73470       {
73471         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73472       };
73473     } catch (std::exception& e) {
73474       {
73475         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73476       };
73477     } catch (Dali::DaliException e) {
73478       {
73479         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73480       };
73481     } catch (...) {
73482       {
73483         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73484       };
73485     }
73486   }
73487
73488   jresult = (void *)result;
73489   return jresult;
73490 }
73491
73492
73493 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73494   float jresult ;
73495   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73496   float arg2 ;
73497   float arg3 ;
73498   float result;
73499
73500   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73501   arg2 = (float)jarg2;
73502   arg3 = (float)jarg3;
73503   {
73504     try {
73505       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->Snap(arg2,arg3);
73506     } catch (std::out_of_range& e) {
73507       {
73508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73509       };
73510     } catch (std::exception& e) {
73511       {
73512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73513       };
73514     } catch (Dali::DaliException e) {
73515       {
73516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73517       };
73518     } catch (...) {
73519       {
73520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73521       };
73522     }
73523   }
73524
73525   jresult = result;
73526   return jresult;
73527 }
73528
73529
73530 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73531   float jresult ;
73532   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73533   unsigned int arg2 ;
73534   unsigned int *arg3 = 0 ;
73535   bool arg4 ;
73536   float result;
73537
73538   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73539   arg2 = (unsigned int)jarg2;
73540   arg3 = (unsigned int *)jarg3;
73541   arg4 = jarg4 ? true : false;
73542   {
73543     try {
73544       result = (float)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73545     } catch (std::out_of_range& e) {
73546       {
73547         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73548       };
73549     } catch (std::exception& e) {
73550       {
73551         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73552       };
73553     } catch (Dali::DaliException e) {
73554       {
73555         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73556       };
73557     } catch (...) {
73558       {
73559         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73560       };
73561     }
73562   }
73563
73564   jresult = result;
73565   return jresult;
73566 }
73567
73568
73569 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73570   unsigned int jresult ;
73571   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73572   float arg2 ;
73573   bool arg3 ;
73574   unsigned int result;
73575
73576   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73577   arg2 = (float)jarg2;
73578   arg3 = jarg3 ? true : false;
73579   {
73580     try {
73581       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73582     } catch (std::out_of_range& e) {
73583       {
73584         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73585       };
73586     } catch (std::exception& e) {
73587       {
73588         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73589       };
73590     } catch (Dali::DaliException e) {
73591       {
73592         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73593       };
73594     } catch (...) {
73595       {
73596         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73597       };
73598     }
73599   }
73600
73601   jresult = result;
73602   return jresult;
73603 }
73604
73605
73606 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DefaultRuler_GetTotalPages(void * jarg1) {
73607   unsigned int jresult ;
73608   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73609   unsigned int result;
73610
73611   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73612   {
73613     try {
73614       result = (unsigned int)((Dali::Toolkit::DefaultRuler const *)arg1)->GetTotalPages();
73615     } catch (std::out_of_range& e) {
73616       {
73617         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73618       };
73619     } catch (std::exception& e) {
73620       {
73621         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73622       };
73623     } catch (Dali::DaliException e) {
73624       {
73625         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73626       };
73627     } catch (...) {
73628       {
73629         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73630       };
73631     }
73632   }
73633
73634   jresult = result;
73635   return jresult;
73636 }
73637
73638
73639 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_DefaultRuler(void * jarg1) {
73640   Dali::Toolkit::DefaultRuler *arg1 = (Dali::Toolkit::DefaultRuler *) 0 ;
73641
73642   arg1 = (Dali::Toolkit::DefaultRuler *)jarg1;
73643   {
73644     try {
73645       delete arg1;
73646     } catch (std::out_of_range& e) {
73647       {
73648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73649       };
73650     } catch (std::exception& e) {
73651       {
73652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73653       };
73654     } catch (Dali::DaliException e) {
73655       {
73656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73657       };
73658     } catch (...) {
73659       {
73660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73661       };
73662     }
73663   }
73664
73665 }
73666
73667
73668 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_0(float jarg1) {
73669   void * jresult ;
73670   float arg1 ;
73671   Dali::Toolkit::FixedRuler *result = 0 ;
73672
73673   arg1 = (float)jarg1;
73674   {
73675     try {
73676       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler(arg1);
73677     } catch (std::out_of_range& e) {
73678       {
73679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73680       };
73681     } catch (std::exception& e) {
73682       {
73683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73684       };
73685     } catch (Dali::DaliException e) {
73686       {
73687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73688       };
73689     } catch (...) {
73690       {
73691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73692       };
73693     }
73694   }
73695
73696   jresult = (void *)result;
73697   return jresult;
73698 }
73699
73700
73701 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FixedRuler__SWIG_1() {
73702   void * jresult ;
73703   Dali::Toolkit::FixedRuler *result = 0 ;
73704
73705   {
73706     try {
73707       result = (Dali::Toolkit::FixedRuler *)new Dali::Toolkit::FixedRuler();
73708     } catch (std::out_of_range& e) {
73709       {
73710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73711       };
73712     } catch (std::exception& e) {
73713       {
73714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73715       };
73716     } catch (Dali::DaliException e) {
73717       {
73718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73719       };
73720     } catch (...) {
73721       {
73722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73723       };
73724     }
73725   }
73726
73727   jresult = (void *)result;
73728   return jresult;
73729 }
73730
73731
73732 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_Snap(void * jarg1, float jarg2, float jarg3) {
73733   float jresult ;
73734   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73735   float arg2 ;
73736   float arg3 ;
73737   float result;
73738
73739   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73740   arg2 = (float)jarg2;
73741   arg3 = (float)jarg3;
73742   {
73743     try {
73744       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->Snap(arg2,arg3);
73745     } catch (std::out_of_range& e) {
73746       {
73747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73748       };
73749     } catch (std::exception& e) {
73750       {
73751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73752       };
73753     } catch (Dali::DaliException e) {
73754       {
73755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73756       };
73757     } catch (...) {
73758       {
73759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73760       };
73761     }
73762   }
73763
73764   jresult = result;
73765   return jresult;
73766 }
73767
73768
73769 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_FixedRuler_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
73770   float jresult ;
73771   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73772   unsigned int arg2 ;
73773   unsigned int *arg3 = 0 ;
73774   bool arg4 ;
73775   float result;
73776
73777   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73778   arg2 = (unsigned int)jarg2;
73779   arg3 = (unsigned int *)jarg3;
73780   arg4 = jarg4 ? true : false;
73781   {
73782     try {
73783       result = (float)((Dali::Toolkit::FixedRuler const *)arg1)->GetPositionFromPage(arg2,*arg3,arg4);
73784     } catch (std::out_of_range& e) {
73785       {
73786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73787       };
73788     } catch (std::exception& e) {
73789       {
73790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73791       };
73792     } catch (Dali::DaliException e) {
73793       {
73794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73795       };
73796     } catch (...) {
73797       {
73798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73799       };
73800     }
73801   }
73802
73803   jresult = result;
73804   return jresult;
73805 }
73806
73807
73808 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
73809   unsigned int jresult ;
73810   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73811   float arg2 ;
73812   bool arg3 ;
73813   unsigned int result;
73814
73815   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73816   arg2 = (float)jarg2;
73817   arg3 = jarg3 ? true : false;
73818   {
73819     try {
73820       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetPageFromPosition(arg2,arg3);
73821     } catch (std::out_of_range& e) {
73822       {
73823         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73824       };
73825     } catch (std::exception& e) {
73826       {
73827         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73828       };
73829     } catch (Dali::DaliException e) {
73830       {
73831         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73832       };
73833     } catch (...) {
73834       {
73835         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73836       };
73837     }
73838   }
73839
73840   jresult = result;
73841   return jresult;
73842 }
73843
73844
73845 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FixedRuler_GetTotalPages(void * jarg1) {
73846   unsigned int jresult ;
73847   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73848   unsigned int result;
73849
73850   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73851   {
73852     try {
73853       result = (unsigned int)((Dali::Toolkit::FixedRuler const *)arg1)->GetTotalPages();
73854     } catch (std::out_of_range& e) {
73855       {
73856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73857       };
73858     } catch (std::exception& e) {
73859       {
73860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73861       };
73862     } catch (Dali::DaliException e) {
73863       {
73864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73865       };
73866     } catch (...) {
73867       {
73868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73869       };
73870     }
73871   }
73872
73873   jresult = result;
73874   return jresult;
73875 }
73876
73877
73878 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FixedRuler(void * jarg1) {
73879   Dali::Toolkit::FixedRuler *arg1 = (Dali::Toolkit::FixedRuler *) 0 ;
73880
73881   arg1 = (Dali::Toolkit::FixedRuler *)jarg1;
73882   {
73883     try {
73884       delete arg1;
73885     } catch (std::out_of_range& e) {
73886       {
73887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
73888       };
73889     } catch (std::exception& e) {
73890       {
73891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
73892       };
73893     } catch (Dali::DaliException e) {
73894       {
73895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
73896       };
73897     } catch (...) {
73898       {
73899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
73900       };
73901     }
73902   }
73903
73904 }
73905
73906
73907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_set(void * jarg1, void * jarg2) {
73908   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73909   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73910
73911   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73912   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73913   if (arg1) (arg1)->scale = *arg2;
73914 }
73915
73916
73917 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_scale_get(void * jarg1) {
73918   void * jresult ;
73919   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73920   Dali::Toolkit::ClampState2D *result = 0 ;
73921
73922   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73923   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->scale);
73924   jresult = (void *)result;
73925   return jresult;
73926 }
73927
73928
73929 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_set(void * jarg1, void * jarg2) {
73930   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73931   Dali::Toolkit::ClampState2D *arg2 = (Dali::Toolkit::ClampState2D *) 0 ;
73932
73933   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73934   arg2 = (Dali::Toolkit::ClampState2D *)jarg2;
73935   if (arg1) (arg1)->position = *arg2;
73936 }
73937
73938
73939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_position_get(void * jarg1) {
73940   void * jresult ;
73941   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73942   Dali::Toolkit::ClampState2D *result = 0 ;
73943
73944   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73945   result = (Dali::Toolkit::ClampState2D *)& ((arg1)->position);
73946   jresult = (void *)result;
73947   return jresult;
73948 }
73949
73950
73951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_set(void * jarg1, int jarg2) {
73952   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73953   Dali::Toolkit::ClampState arg2 ;
73954
73955   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73956   arg2 = (Dali::Toolkit::ClampState)jarg2;
73957   if (arg1) (arg1)->rotation = arg2;
73958 }
73959
73960
73961 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_ClampEvent_rotation_get(void * jarg1) {
73962   int jresult ;
73963   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
73964   Dali::Toolkit::ClampState result;
73965
73966   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
73967   result = (Dali::Toolkit::ClampState) ((arg1)->rotation);
73968   jresult = (int)result;
73969   return jresult;
73970 }
73971
73972
73973 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_ClampEvent() {
73974   void * jresult ;
73975   Dali::Toolkit::ScrollView::ClampEvent *result = 0 ;
73976
73977   {
73978     try {
73979       result = (Dali::Toolkit::ScrollView::ClampEvent *)new Dali::Toolkit::ScrollView::ClampEvent();
73980     } catch (std::out_of_range& e) {
73981       {
73982         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
73983       };
73984     } catch (std::exception& e) {
73985       {
73986         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
73987       };
73988     } catch (Dali::DaliException e) {
73989       {
73990         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
73991       };
73992     } catch (...) {
73993       {
73994         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
73995       };
73996     }
73997   }
73998
73999   jresult = (void *)result;
74000   return jresult;
74001 }
74002
74003
74004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_ClampEvent(void * jarg1) {
74005   Dali::Toolkit::ScrollView::ClampEvent *arg1 = (Dali::Toolkit::ScrollView::ClampEvent *) 0 ;
74006
74007   arg1 = (Dali::Toolkit::ScrollView::ClampEvent *)jarg1;
74008   {
74009     try {
74010       delete arg1;
74011     } catch (std::out_of_range& e) {
74012       {
74013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74014       };
74015     } catch (std::exception& e) {
74016       {
74017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74018       };
74019     } catch (Dali::DaliException e) {
74020       {
74021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74022       };
74023     } catch (...) {
74024       {
74025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74026       };
74027     }
74028   }
74029
74030 }
74031
74032
74033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_set(void * jarg1, int jarg2) {
74034   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74035   Dali::Toolkit::SnapType arg2 ;
74036
74037   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74038   arg2 = (Dali::Toolkit::SnapType)jarg2;
74039   if (arg1) (arg1)->type = arg2;
74040 }
74041
74042
74043 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_type_get(void * jarg1) {
74044   int jresult ;
74045   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74046   Dali::Toolkit::SnapType result;
74047
74048   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74049   result = (Dali::Toolkit::SnapType) ((arg1)->type);
74050   jresult = (int)result;
74051   return jresult;
74052 }
74053
74054
74055 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_set(void * jarg1, void * jarg2) {
74056   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74057   Dali::Vector2 *arg2 = (Dali::Vector2 *) 0 ;
74058
74059   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74060   arg2 = (Dali::Vector2 *)jarg2;
74061   if (arg1) (arg1)->position = *arg2;
74062 }
74063
74064
74065 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_position_get(void * jarg1) {
74066   void * jresult ;
74067   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74068   Dali::Vector2 *result = 0 ;
74069
74070   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74071   result = (Dali::Vector2 *)& ((arg1)->position);
74072   jresult = (void *)result;
74073   return jresult;
74074 }
74075
74076
74077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_set(void * jarg1, float jarg2) {
74078   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74079   float arg2 ;
74080
74081   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74082   arg2 = (float)jarg2;
74083   if (arg1) (arg1)->duration = arg2;
74084 }
74085
74086
74087 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_SnapEvent_duration_get(void * jarg1) {
74088   float jresult ;
74089   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74090   float result;
74091
74092   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74093   result = (float) ((arg1)->duration);
74094   jresult = result;
74095   return jresult;
74096 }
74097
74098
74099 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_SnapEvent() {
74100   void * jresult ;
74101   Dali::Toolkit::ScrollView::SnapEvent *result = 0 ;
74102
74103   {
74104     try {
74105       result = (Dali::Toolkit::ScrollView::SnapEvent *)new Dali::Toolkit::ScrollView::SnapEvent();
74106     } catch (std::out_of_range& e) {
74107       {
74108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74109       };
74110     } catch (std::exception& e) {
74111       {
74112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74113       };
74114     } catch (Dali::DaliException e) {
74115       {
74116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74117       };
74118     } catch (...) {
74119       {
74120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74121       };
74122     }
74123   }
74124
74125   jresult = (void *)result;
74126   return jresult;
74127 }
74128
74129
74130 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_SnapEvent(void * jarg1) {
74131   Dali::Toolkit::ScrollView::SnapEvent *arg1 = (Dali::Toolkit::ScrollView::SnapEvent *) 0 ;
74132
74133   arg1 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg1;
74134   {
74135     try {
74136       delete arg1;
74137     } catch (std::out_of_range& e) {
74138       {
74139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74140       };
74141     } catch (std::exception& e) {
74142       {
74143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74144       };
74145     } catch (Dali::DaliException e) {
74146       {
74147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74148       };
74149     } catch (...) {
74150       {
74151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74152       };
74153     }
74154   }
74155
74156 }
74157
74158
74159 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_ENABLED_get() {
74160   int jresult ;
74161   int result;
74162
74163   result = (int)Dali::Toolkit::ScrollView::Property::WRAP_ENABLED;
74164   jresult = (int)result;
74165   return jresult;
74166 }
74167
74168
74169 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_ENABLED_get() {
74170   int jresult ;
74171   int result;
74172
74173   result = (int)Dali::Toolkit::ScrollView::Property::PANNING_ENABLED;
74174   jresult = (int)result;
74175   return jresult;
74176 }
74177
74178
74179 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_AXIS_AUTO_LOCK_ENABLED_get() {
74180   int jresult ;
74181   int result;
74182
74183   result = (int)Dali::Toolkit::ScrollView::Property::AXIS_AUTO_LOCK_ENABLED;
74184   jresult = (int)result;
74185   return jresult;
74186 }
74187
74188
74189 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WHEEL_SCROLL_DISTANCE_STEP_get() {
74190   int jresult ;
74191   int result;
74192
74193   result = (int)Dali::Toolkit::ScrollView::Property::WHEEL_SCROLL_DISTANCE_STEP;
74194   jresult = (int)result;
74195   return jresult;
74196 }
74197
74198
74199 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_MODE_get() {
74200   int jresult ;
74201   int result;
74202
74203   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_MODE;
74204   jresult = (int)result;
74205   return jresult;
74206 }
74207
74208 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_get() {
74209   int jresult ;
74210   int result;
74211
74212   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION;
74213   jresult = (int)result;
74214   return jresult;
74215 }
74216
74217
74218 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_get() {
74219   int jresult ;
74220   int result;
74221
74222   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION;
74223   jresult = (int)result;
74224   return jresult;
74225 }
74226
74227
74228 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_X_get() {
74229   int jresult ;
74230   int result;
74231
74232   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_X;
74233   jresult = (int)result;
74234   return jresult;
74235 }
74236
74237
74238 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_Y_get() {
74239   int jresult ;
74240   int result;
74241
74242   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_Y;
74243   jresult = (int)result;
74244   return jresult;
74245 }
74246
74247
74248 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_get() {
74249   int jresult ;
74250   int result;
74251
74252   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX;
74253   jresult = (int)result;
74254   return jresult;
74255 }
74256
74257
74258 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_X_get() {
74259   int jresult ;
74260   int result;
74261
74262   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_X;
74263   jresult = (int)result;
74264   return jresult;
74265 }
74266
74267
74268 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_PRE_POSITION_MAX_Y_get() {
74269   int jresult ;
74270   int result;
74271
74272   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_PRE_POSITION_MAX_Y;
74273   jresult = (int)result;
74274   return jresult;
74275 }
74276
74277
74278 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_X_get() {
74279   int jresult ;
74280   int result;
74281
74282   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_X;
74283   jresult = (int)result;
74284   return jresult;
74285 }
74286
74287
74288 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_OVERSHOOT_Y_get() {
74289   int jresult ;
74290   int result;
74291
74292   result = (int)Dali::Toolkit::ScrollView::Property::OVERSHOOT_Y;
74293   jresult = (int)result;
74294   return jresult;
74295 }
74296
74297
74298 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_get() {
74299   int jresult ;
74300   int result;
74301
74302   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL;
74303   jresult = (int)result;
74304   return jresult;
74305 }
74306
74307
74308 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_X_get() {
74309   int jresult ;
74310   int result;
74311
74312   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_X;
74313   jresult = (int)result;
74314   return jresult;
74315 }
74316
74317
74318 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_FINAL_Y_get() {
74319   int jresult ;
74320   int result;
74321
74322   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_FINAL_Y;
74323   jresult = (int)result;
74324   return jresult;
74325 }
74326
74327
74328 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_WRAP_get() {
74329   int jresult ;
74330   int result;
74331
74332   result = (int)Dali::Toolkit::ScrollView::Property::WRAP;
74333   jresult = (int)result;
74334   return jresult;
74335 }
74336
74337
74338 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_PANNING_get() {
74339   int jresult ;
74340   int result;
74341
74342   result = (int)Dali::Toolkit::ScrollView::Property::PANNING;
74343   jresult = (int)result;
74344   return jresult;
74345 }
74346
74347
74348 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLLING_get() {
74349   int jresult ;
74350   int result;
74351
74352   result = (int)Dali::Toolkit::ScrollView::Property::SCROLLING;
74353   jresult = (int)result;
74354   return jresult;
74355 }
74356
74357
74358 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_get() {
74359   int jresult ;
74360   int result;
74361
74362   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE;
74363   jresult = (int)result;
74364   return jresult;
74365 }
74366
74367
74368 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_X_get() {
74369   int jresult ;
74370   int result;
74371
74372   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_X;
74373   jresult = (int)result;
74374   return jresult;
74375 }
74376
74377
74378 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_SIZE_Y_get() {
74379   int jresult ;
74380   int result;
74381
74382   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_SIZE_Y;
74383   jresult = (int)result;
74384   return jresult;
74385 }
74386
74387
74388 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_DOMAIN_OFFSET_get() {
74389   int jresult ;
74390   int result;
74391
74392   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_DOMAIN_OFFSET;
74393   jresult = (int)result;
74394   return jresult;
74395 }
74396
74397
74398 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_SCROLL_POSITION_DELTA_get() {
74399   int jresult ;
74400   int result;
74401
74402   result = (int)Dali::Toolkit::ScrollView::Property::SCROLL_POSITION_DELTA;
74403   jresult = (int)result;
74404   return jresult;
74405 }
74406
74407
74408 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_Property_START_PAGE_POSITION_get() {
74409   int jresult ;
74410   int result;
74411
74412   result = (int)Dali::Toolkit::ScrollView::Property::START_PAGE_POSITION;
74413   jresult = (int)result;
74414   return jresult;
74415 }
74416
74417
74418 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView_Property() {
74419   void * jresult ;
74420   Dali::Toolkit::ScrollView::Property *result = 0 ;
74421
74422   {
74423     try {
74424       result = (Dali::Toolkit::ScrollView::Property *)new Dali::Toolkit::ScrollView::Property();
74425     } catch (std::out_of_range& e) {
74426       {
74427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74428       };
74429     } catch (std::exception& e) {
74430       {
74431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74432       };
74433     } catch (Dali::DaliException e) {
74434       {
74435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74436       };
74437     } catch (...) {
74438       {
74439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74440       };
74441     }
74442   }
74443
74444   jresult = (void *)result;
74445   return jresult;
74446 }
74447
74448
74449 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView_Property(void * jarg1) {
74450   Dali::Toolkit::ScrollView::Property *arg1 = (Dali::Toolkit::ScrollView::Property *) 0 ;
74451
74452   arg1 = (Dali::Toolkit::ScrollView::Property *)jarg1;
74453   {
74454     try {
74455       delete arg1;
74456     } catch (std::out_of_range& e) {
74457       {
74458         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74459       };
74460     } catch (std::exception& e) {
74461       {
74462         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74463       };
74464     } catch (Dali::DaliException e) {
74465       {
74466         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74467       };
74468     } catch (...) {
74469       {
74470         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74471       };
74472     }
74473   }
74474
74475 }
74476
74477
74478 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_0() {
74479   void * jresult ;
74480   Dali::Toolkit::ScrollView *result = 0 ;
74481
74482   {
74483     try {
74484       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView();
74485     } catch (std::out_of_range& e) {
74486       {
74487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74488       };
74489     } catch (std::exception& e) {
74490       {
74491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74492       };
74493     } catch (Dali::DaliException e) {
74494       {
74495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74496       };
74497     } catch (...) {
74498       {
74499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74500       };
74501     }
74502   }
74503
74504   jresult = (void *)result;
74505   return jresult;
74506 }
74507
74508
74509 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollView__SWIG_1(void * jarg1) {
74510   void * jresult ;
74511   Dali::Toolkit::ScrollView *arg1 = 0 ;
74512   Dali::Toolkit::ScrollView *result = 0 ;
74513
74514   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74515   if (!arg1) {
74516     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74517     return 0;
74518   }
74519   {
74520     try {
74521       result = (Dali::Toolkit::ScrollView *)new Dali::Toolkit::ScrollView((Dali::Toolkit::ScrollView const &)*arg1);
74522     } catch (std::out_of_range& e) {
74523       {
74524         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74525       };
74526     } catch (std::exception& e) {
74527       {
74528         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74529       };
74530     } catch (Dali::DaliException e) {
74531       {
74532         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74533       };
74534     } catch (...) {
74535       {
74536         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74537       };
74538     }
74539   }
74540
74541   jresult = (void *)result;
74542   return jresult;
74543 }
74544
74545
74546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_Assign(void * jarg1, void * jarg2) {
74547   void * jresult ;
74548   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74549   Dali::Toolkit::ScrollView *arg2 = 0 ;
74550   Dali::Toolkit::ScrollView *result = 0 ;
74551
74552   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74553   arg2 = (Dali::Toolkit::ScrollView *)jarg2;
74554   if (!arg2) {
74555     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView const & type is null", 0);
74556     return 0;
74557   }
74558   {
74559     try {
74560       result = (Dali::Toolkit::ScrollView *) &(arg1)->operator =((Dali::Toolkit::ScrollView const &)*arg2);
74561     } catch (std::out_of_range& e) {
74562       {
74563         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74564       };
74565     } catch (std::exception& e) {
74566       {
74567         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74568       };
74569     } catch (Dali::DaliException e) {
74570       {
74571         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74572       };
74573     } catch (...) {
74574       {
74575         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74576       };
74577     }
74578   }
74579
74580   jresult = (void *)result;
74581   return jresult;
74582 }
74583
74584
74585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollView(void * jarg1) {
74586   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74587
74588   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74589   {
74590     try {
74591       delete arg1;
74592     } catch (std::out_of_range& e) {
74593       {
74594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74595       };
74596     } catch (std::exception& e) {
74597       {
74598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74599       };
74600     } catch (Dali::DaliException e) {
74601       {
74602         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74603       };
74604     } catch (...) {
74605       {
74606         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74607       };
74608     }
74609   }
74610
74611 }
74612
74613
74614 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_New() {
74615   void * jresult ;
74616   Dali::Toolkit::ScrollView result;
74617
74618   {
74619     try {
74620       result = Dali::Toolkit::ScrollView::New();
74621     } catch (std::out_of_range& e) {
74622       {
74623         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74624       };
74625     } catch (std::exception& e) {
74626       {
74627         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74628       };
74629     } catch (Dali::DaliException e) {
74630       {
74631         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74632       };
74633     } catch (...) {
74634       {
74635         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74636       };
74637     }
74638   }
74639
74640   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74641   return jresult;
74642 }
74643
74644
74645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_DownCast(void * jarg1) {
74646   void * jresult ;
74647   Dali::BaseHandle arg1 ;
74648   Dali::BaseHandle *argp1 ;
74649   Dali::Toolkit::ScrollView result;
74650
74651   argp1 = (Dali::BaseHandle *)jarg1;
74652   if (!argp1) {
74653     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
74654     return 0;
74655   }
74656   arg1 = *argp1;
74657   {
74658     try {
74659       result = Dali::Toolkit::ScrollView::DownCast(arg1);
74660     } catch (std::out_of_range& e) {
74661       {
74662         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74663       };
74664     } catch (std::exception& e) {
74665       {
74666         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74667       };
74668     } catch (Dali::DaliException e) {
74669       {
74670         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74671       };
74672     } catch (...) {
74673       {
74674         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74675       };
74676     }
74677   }
74678
74679   jresult = new Dali::Toolkit::ScrollView((const Dali::Toolkit::ScrollView &)result);
74680   return jresult;
74681 }
74682
74683
74684 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapAlphaFunction(void * jarg1) {
74685   void * jresult ;
74686   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74687   Dali::AlphaFunction result;
74688
74689   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74690   {
74691     try {
74692       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapAlphaFunction();
74693     } catch (std::out_of_range& e) {
74694       {
74695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74696       };
74697     } catch (std::exception& e) {
74698       {
74699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74700       };
74701     } catch (Dali::DaliException e) {
74702       {
74703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74704       };
74705     } catch (...) {
74706       {
74707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74708       };
74709     }
74710   }
74711
74712   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74713   return jresult;
74714 }
74715
74716
74717 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapAlphaFunction(void * jarg1, void * jarg2) {
74718   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74719   Dali::AlphaFunction arg2 ;
74720   Dali::AlphaFunction *argp2 ;
74721
74722   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74723   argp2 = (Dali::AlphaFunction *)jarg2;
74724   if (!argp2) {
74725     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74726     return ;
74727   }
74728   arg2 = *argp2;
74729   {
74730     try {
74731       (arg1)->SetScrollSnapAlphaFunction(arg2);
74732     } catch (std::out_of_range& e) {
74733       {
74734         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74735       };
74736     } catch (std::exception& e) {
74737       {
74738         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74739       };
74740     } catch (Dali::DaliException e) {
74741       {
74742         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74743       };
74744     } catch (...) {
74745       {
74746         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74747       };
74748     }
74749   }
74750
74751 }
74752
74753
74754 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickAlphaFunction(void * jarg1) {
74755   void * jresult ;
74756   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74757   Dali::AlphaFunction result;
74758
74759   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74760   {
74761     try {
74762       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickAlphaFunction();
74763     } catch (std::out_of_range& e) {
74764       {
74765         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74766       };
74767     } catch (std::exception& e) {
74768       {
74769         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74770       };
74771     } catch (Dali::DaliException e) {
74772       {
74773         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74774       };
74775     } catch (...) {
74776       {
74777         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74778       };
74779     }
74780   }
74781
74782   jresult = new Dali::AlphaFunction((const Dali::AlphaFunction &)result);
74783   return jresult;
74784 }
74785
74786
74787 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickAlphaFunction(void * jarg1, void * jarg2) {
74788   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74789   Dali::AlphaFunction arg2 ;
74790   Dali::AlphaFunction *argp2 ;
74791
74792   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74793   argp2 = (Dali::AlphaFunction *)jarg2;
74794   if (!argp2) {
74795     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
74796     return ;
74797   }
74798   arg2 = *argp2;
74799   {
74800     try {
74801       (arg1)->SetScrollFlickAlphaFunction(arg2);
74802     } catch (std::out_of_range& e) {
74803       {
74804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74805       };
74806     } catch (std::exception& e) {
74807       {
74808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74809       };
74810     } catch (Dali::DaliException e) {
74811       {
74812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74813       };
74814     } catch (...) {
74815       {
74816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74817       };
74818     }
74819   }
74820
74821 }
74822
74823
74824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollSnapDuration(void * jarg1) {
74825   float jresult ;
74826   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74827   float result;
74828
74829   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74830   {
74831     try {
74832       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollSnapDuration();
74833     } catch (std::out_of_range& e) {
74834       {
74835         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74836       };
74837     } catch (std::exception& e) {
74838       {
74839         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74840       };
74841     } catch (Dali::DaliException e) {
74842       {
74843         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74844       };
74845     } catch (...) {
74846       {
74847         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74848       };
74849     }
74850   }
74851
74852   jresult = result;
74853   return jresult;
74854 }
74855
74856
74857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSnapDuration(void * jarg1, float jarg2) {
74858   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74859   float arg2 ;
74860
74861   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74862   arg2 = (float)jarg2;
74863   {
74864     try {
74865       (arg1)->SetScrollSnapDuration(arg2);
74866     } catch (std::out_of_range& e) {
74867       {
74868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74869       };
74870     } catch (std::exception& e) {
74871       {
74872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74873       };
74874     } catch (Dali::DaliException e) {
74875       {
74876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74877       };
74878     } catch (...) {
74879       {
74880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74881       };
74882     }
74883   }
74884
74885 }
74886
74887
74888 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollFlickDuration(void * jarg1) {
74889   float jresult ;
74890   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74891   float result;
74892
74893   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74894   {
74895     try {
74896       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollFlickDuration();
74897     } catch (std::out_of_range& e) {
74898       {
74899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
74900       };
74901     } catch (std::exception& e) {
74902       {
74903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
74904       };
74905     } catch (Dali::DaliException e) {
74906       {
74907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
74908       };
74909     } catch (...) {
74910       {
74911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
74912       };
74913     }
74914   }
74915
74916   jresult = result;
74917   return jresult;
74918 }
74919
74920
74921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollFlickDuration(void * jarg1, float jarg2) {
74922   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74923   float arg2 ;
74924
74925   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74926   arg2 = (float)jarg2;
74927   {
74928     try {
74929       (arg1)->SetScrollFlickDuration(arg2);
74930     } catch (std::out_of_range& e) {
74931       {
74932         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74933       };
74934     } catch (std::exception& e) {
74935       {
74936         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74937       };
74938     } catch (Dali::DaliException e) {
74939       {
74940         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74941       };
74942     } catch (...) {
74943       {
74944         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74945       };
74946     }
74947   }
74948
74949 }
74950
74951
74952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerX(void * jarg1, void * jarg2) {
74953   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74954   Dali::Toolkit::RulerPtr arg2 ;
74955   Dali::Toolkit::RulerPtr *argp2 ;
74956
74957   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74958   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74959   if (!argp2) {
74960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74961     return ;
74962   }
74963   arg2 = *argp2;
74964   {
74965     try {
74966       (arg1)->SetRulerX(arg2);
74967     } catch (std::out_of_range& e) {
74968       {
74969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
74970       };
74971     } catch (std::exception& e) {
74972       {
74973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
74974       };
74975     } catch (Dali::DaliException e) {
74976       {
74977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
74978       };
74979     } catch (...) {
74980       {
74981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
74982       };
74983     }
74984   }
74985
74986 }
74987
74988
74989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetRulerY(void * jarg1, void * jarg2) {
74990   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
74991   Dali::Toolkit::RulerPtr arg2 ;
74992   Dali::Toolkit::RulerPtr *argp2 ;
74993
74994   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
74995   argp2 = (Dali::Toolkit::RulerPtr *)jarg2;
74996   if (!argp2) {
74997     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerPtr", 0);
74998     return ;
74999   }
75000   arg2 = *argp2;
75001   {
75002     try {
75003       (arg1)->SetRulerY(arg2);
75004     } catch (std::out_of_range& e) {
75005       {
75006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75007       };
75008     } catch (std::exception& e) {
75009       {
75010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75011       };
75012     } catch (Dali::DaliException e) {
75013       {
75014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75015       };
75016     } catch (...) {
75017       {
75018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75019       };
75020     }
75021   }
75022
75023 }
75024
75025
75026 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollSensitive(void * jarg1, unsigned int jarg2) {
75027   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75028   bool arg2 ;
75029
75030   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75031   arg2 = jarg2 ? true : false;
75032   {
75033     try {
75034       (arg1)->SetScrollSensitive(arg2);
75035     } catch (std::out_of_range& e) {
75036       {
75037         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75038       };
75039     } catch (std::exception& e) {
75040       {
75041         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75042       };
75043     } catch (Dali::DaliException e) {
75044       {
75045         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75046       };
75047     } catch (...) {
75048       {
75049         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75050       };
75051     }
75052   }
75053
75054 }
75055
75056
75057 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxOvershoot(void * jarg1, float jarg2, float jarg3) {
75058   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75059   float arg2 ;
75060   float arg3 ;
75061
75062   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75063   arg2 = (float)jarg2;
75064   arg3 = (float)jarg3;
75065   {
75066     try {
75067       (arg1)->SetMaxOvershoot(arg2,arg3);
75068     } catch (std::out_of_range& e) {
75069       {
75070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75071       };
75072     } catch (std::exception& e) {
75073       {
75074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75075       };
75076     } catch (Dali::DaliException e) {
75077       {
75078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75079       };
75080     } catch (...) {
75081       {
75082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75083       };
75084     }
75085   }
75086
75087 }
75088
75089
75090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootAlphaFunction(void * jarg1, void * jarg2) {
75091   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75092   Dali::AlphaFunction arg2 ;
75093   Dali::AlphaFunction *argp2 ;
75094
75095   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75096   argp2 = (Dali::AlphaFunction *)jarg2;
75097   if (!argp2) {
75098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75099     return ;
75100   }
75101   arg2 = *argp2;
75102   {
75103     try {
75104       (arg1)->SetSnapOvershootAlphaFunction(arg2);
75105     } catch (std::out_of_range& e) {
75106       {
75107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75108       };
75109     } catch (std::exception& e) {
75110       {
75111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75112       };
75113     } catch (Dali::DaliException e) {
75114       {
75115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75116       };
75117     } catch (...) {
75118       {
75119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75120       };
75121     }
75122   }
75123
75124 }
75125
75126
75127 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetSnapOvershootDuration(void * jarg1, float jarg2) {
75128   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75129   float arg2 ;
75130
75131   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75132   arg2 = (float)jarg2;
75133   {
75134     try {
75135       (arg1)->SetSnapOvershootDuration(arg2);
75136     } catch (std::out_of_range& e) {
75137       {
75138         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75139       };
75140     } catch (std::exception& e) {
75141       {
75142         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75143       };
75144     } catch (Dali::DaliException e) {
75145       {
75146         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75147       };
75148     } catch (...) {
75149       {
75150         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75151       };
75152     }
75153   }
75154
75155 }
75156
75157
75158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetActorAutoSnap(void * jarg1, unsigned int jarg2) {
75159   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75160   bool arg2 ;
75161
75162   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75163   arg2 = jarg2 ? true : false;
75164   {
75165     try {
75166       (arg1)->SetActorAutoSnap(arg2);
75167     } catch (std::out_of_range& e) {
75168       {
75169         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75170       };
75171     } catch (std::exception& e) {
75172       {
75173         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75174       };
75175     } catch (Dali::DaliException e) {
75176       {
75177         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75178       };
75179     } catch (...) {
75180       {
75181         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75182       };
75183     }
75184   }
75185
75186 }
75187
75188
75189 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWrapMode(void * jarg1, unsigned int jarg2) {
75190   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75191   bool arg2 ;
75192
75193   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75194   arg2 = jarg2 ? true : false;
75195   {
75196     try {
75197       (arg1)->SetWrapMode(arg2);
75198     } catch (std::out_of_range& e) {
75199       {
75200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75201       };
75202     } catch (std::exception& e) {
75203       {
75204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75205       };
75206     } catch (Dali::DaliException e) {
75207       {
75208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75209       };
75210     } catch (...) {
75211       {
75212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75213       };
75214     }
75215   }
75216
75217 }
75218
75219
75220 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ScrollView_GetScrollUpdateDistance(void * jarg1) {
75221   int jresult ;
75222   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75223   int result;
75224
75225   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75226   {
75227     try {
75228       result = (int)((Dali::Toolkit::ScrollView const *)arg1)->GetScrollUpdateDistance();
75229     } catch (std::out_of_range& e) {
75230       {
75231         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75232       };
75233     } catch (std::exception& e) {
75234       {
75235         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75236       };
75237     } catch (Dali::DaliException e) {
75238       {
75239         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75240       };
75241     } catch (...) {
75242       {
75243         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75244       };
75245     }
75246   }
75247
75248   jresult = result;
75249   return jresult;
75250 }
75251
75252
75253 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollUpdateDistance(void * jarg1, int jarg2) {
75254   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75255   int arg2 ;
75256
75257   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75258   arg2 = (int)jarg2;
75259   {
75260     try {
75261       (arg1)->SetScrollUpdateDistance(arg2);
75262     } catch (std::out_of_range& e) {
75263       {
75264         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75265       };
75266     } catch (std::exception& e) {
75267       {
75268         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75269       };
75270     } catch (Dali::DaliException e) {
75271       {
75272         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75273       };
75274     } catch (...) {
75275       {
75276         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75277       };
75278     }
75279   }
75280
75281 }
75282
75283
75284 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLock(void * jarg1) {
75285   unsigned int jresult ;
75286   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75287   bool result;
75288
75289   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75290   {
75291     try {
75292       result = (bool)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLock();
75293     } catch (std::out_of_range& e) {
75294       {
75295         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75296       };
75297     } catch (std::exception& e) {
75298       {
75299         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75300       };
75301     } catch (Dali::DaliException e) {
75302       {
75303         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75304       };
75305     } catch (...) {
75306       {
75307         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75308       };
75309     }
75310   }
75311
75312   jresult = result;
75313   return jresult;
75314 }
75315
75316
75317 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLock(void * jarg1, unsigned int jarg2) {
75318   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75319   bool arg2 ;
75320
75321   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75322   arg2 = jarg2 ? true : false;
75323   {
75324     try {
75325       (arg1)->SetAxisAutoLock(arg2);
75326     } catch (std::out_of_range& e) {
75327       {
75328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75329       };
75330     } catch (std::exception& e) {
75331       {
75332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75333       };
75334     } catch (Dali::DaliException e) {
75335       {
75336         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75337       };
75338     } catch (...) {
75339       {
75340         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75341       };
75342     }
75343   }
75344
75345 }
75346
75347
75348 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetAxisAutoLockGradient(void * jarg1) {
75349   float jresult ;
75350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75351   float result;
75352
75353   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75354   {
75355     try {
75356       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetAxisAutoLockGradient();
75357     } catch (std::out_of_range& e) {
75358       {
75359         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75360       };
75361     } catch (std::exception& e) {
75362       {
75363         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75364       };
75365     } catch (Dali::DaliException e) {
75366       {
75367         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75368       };
75369     } catch (...) {
75370       {
75371         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75372       };
75373     }
75374   }
75375
75376   jresult = result;
75377   return jresult;
75378 }
75379
75380
75381 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetAxisAutoLockGradient(void * jarg1, float jarg2) {
75382   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75383   float arg2 ;
75384
75385   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75386   arg2 = (float)jarg2;
75387   {
75388     try {
75389       (arg1)->SetAxisAutoLockGradient(arg2);
75390     } catch (std::out_of_range& e) {
75391       {
75392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75393       };
75394     } catch (std::exception& e) {
75395       {
75396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75397       };
75398     } catch (Dali::DaliException e) {
75399       {
75400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75401       };
75402     } catch (...) {
75403       {
75404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75405       };
75406     }
75407   }
75408
75409 }
75410
75411
75412 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFrictionCoefficient(void * jarg1) {
75413   float jresult ;
75414   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75415   float result;
75416
75417   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75418   {
75419     try {
75420       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFrictionCoefficient();
75421     } catch (std::out_of_range& e) {
75422       {
75423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75424       };
75425     } catch (std::exception& e) {
75426       {
75427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75428       };
75429     } catch (Dali::DaliException e) {
75430       {
75431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75432       };
75433     } catch (...) {
75434       {
75435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75436       };
75437     }
75438   }
75439
75440   jresult = result;
75441   return jresult;
75442 }
75443
75444
75445 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFrictionCoefficient(void * jarg1, float jarg2) {
75446   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75447   float arg2 ;
75448
75449   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75450   arg2 = (float)jarg2;
75451   {
75452     try {
75453       (arg1)->SetFrictionCoefficient(arg2);
75454     } catch (std::out_of_range& e) {
75455       {
75456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75457       };
75458     } catch (std::exception& e) {
75459       {
75460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75461       };
75462     } catch (Dali::DaliException e) {
75463       {
75464         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75465       };
75466     } catch (...) {
75467       {
75468         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75469       };
75470     }
75471   }
75472
75473 }
75474
75475
75476 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetFlickSpeedCoefficient(void * jarg1) {
75477   float jresult ;
75478   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75479   float result;
75480
75481   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75482   {
75483     try {
75484       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetFlickSpeedCoefficient();
75485     } catch (std::out_of_range& e) {
75486       {
75487         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75488       };
75489     } catch (std::exception& e) {
75490       {
75491         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75492       };
75493     } catch (Dali::DaliException e) {
75494       {
75495         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75496       };
75497     } catch (...) {
75498       {
75499         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75500       };
75501     }
75502   }
75503
75504   jresult = result;
75505   return jresult;
75506 }
75507
75508
75509 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetFlickSpeedCoefficient(void * jarg1, float jarg2) {
75510   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75511   float arg2 ;
75512
75513   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75514   arg2 = (float)jarg2;
75515   {
75516     try {
75517       (arg1)->SetFlickSpeedCoefficient(arg2);
75518     } catch (std::out_of_range& e) {
75519       {
75520         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75521       };
75522     } catch (std::exception& e) {
75523       {
75524         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75525       };
75526     } catch (Dali::DaliException e) {
75527       {
75528         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75529       };
75530     } catch (...) {
75531       {
75532         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75533       };
75534     }
75535   }
75536
75537 }
75538
75539
75540 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumDistanceForFlick(void * jarg1) {
75541   void * jresult ;
75542   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75543   Dali::Vector2 result;
75544
75545   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75546   {
75547     try {
75548       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumDistanceForFlick();
75549     } catch (std::out_of_range& e) {
75550       {
75551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75552       };
75553     } catch (std::exception& e) {
75554       {
75555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75556       };
75557     } catch (Dali::DaliException e) {
75558       {
75559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75560       };
75561     } catch (...) {
75562       {
75563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75564       };
75565     }
75566   }
75567
75568   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75569   return jresult;
75570 }
75571
75572
75573 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumDistanceForFlick(void * jarg1, void * jarg2) {
75574   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75575   Dali::Vector2 *arg2 = 0 ;
75576
75577   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75578   arg2 = (Dali::Vector2 *)jarg2;
75579   if (!arg2) {
75580     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75581     return ;
75582   }
75583   {
75584     try {
75585       (arg1)->SetMinimumDistanceForFlick((Dali::Vector2 const &)*arg2);
75586     } catch (std::out_of_range& e) {
75587       {
75588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75589       };
75590     } catch (std::exception& e) {
75591       {
75592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75593       };
75594     } catch (Dali::DaliException e) {
75595       {
75596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75597       };
75598     } catch (...) {
75599       {
75600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75601       };
75602     }
75603   }
75604
75605 }
75606
75607
75608 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMinimumSpeedForFlick(void * jarg1) {
75609   float jresult ;
75610   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75611   float result;
75612
75613   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75614   {
75615     try {
75616       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMinimumSpeedForFlick();
75617     } catch (std::out_of_range& e) {
75618       {
75619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75620       };
75621     } catch (std::exception& e) {
75622       {
75623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75624       };
75625     } catch (Dali::DaliException e) {
75626       {
75627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75628       };
75629     } catch (...) {
75630       {
75631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75632       };
75633     }
75634   }
75635
75636   jresult = result;
75637   return jresult;
75638 }
75639
75640
75641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMinimumSpeedForFlick(void * jarg1, float jarg2) {
75642   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75643   float arg2 ;
75644
75645   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75646   arg2 = (float)jarg2;
75647   {
75648     try {
75649       (arg1)->SetMinimumSpeedForFlick(arg2);
75650     } catch (std::out_of_range& e) {
75651       {
75652         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75653       };
75654     } catch (std::exception& e) {
75655       {
75656         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75657       };
75658     } catch (Dali::DaliException e) {
75659       {
75660         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75661       };
75662     } catch (...) {
75663       {
75664         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75665       };
75666     }
75667   }
75668
75669 }
75670
75671
75672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_ScrollView_GetMaxFlickSpeed(void * jarg1) {
75673   float jresult ;
75674   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75675   float result;
75676
75677   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75678   {
75679     try {
75680       result = (float)((Dali::Toolkit::ScrollView const *)arg1)->GetMaxFlickSpeed();
75681     } catch (std::out_of_range& e) {
75682       {
75683         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75684       };
75685     } catch (std::exception& e) {
75686       {
75687         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75688       };
75689     } catch (Dali::DaliException e) {
75690       {
75691         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75692       };
75693     } catch (...) {
75694       {
75695         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75696       };
75697     }
75698   }
75699
75700   jresult = result;
75701   return jresult;
75702 }
75703
75704
75705 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetMaxFlickSpeed(void * jarg1, float jarg2) {
75706   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75707   float arg2 ;
75708
75709   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75710   arg2 = (float)jarg2;
75711   {
75712     try {
75713       (arg1)->SetMaxFlickSpeed(arg2);
75714     } catch (std::out_of_range& e) {
75715       {
75716         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75717       };
75718     } catch (std::exception& e) {
75719       {
75720         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75721       };
75722     } catch (Dali::DaliException e) {
75723       {
75724         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75725       };
75726     } catch (...) {
75727       {
75728         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75729       };
75730     }
75731   }
75732
75733 }
75734
75735
75736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetWheelScrollDistanceStep(void * jarg1) {
75737   void * jresult ;
75738   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75739   Dali::Vector2 result;
75740
75741   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75742   {
75743     try {
75744       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetWheelScrollDistanceStep();
75745     } catch (std::out_of_range& e) {
75746       {
75747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75748       };
75749     } catch (std::exception& e) {
75750       {
75751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75752       };
75753     } catch (Dali::DaliException e) {
75754       {
75755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75756       };
75757     } catch (...) {
75758       {
75759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75760       };
75761     }
75762   }
75763
75764   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75765   return jresult;
75766 }
75767
75768
75769 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetWheelScrollDistanceStep(void * jarg1, void * jarg2) {
75770   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75771   Dali::Vector2 arg2 ;
75772   Dali::Vector2 *argp2 ;
75773
75774   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75775   argp2 = (Dali::Vector2 *)jarg2;
75776   if (!argp2) {
75777     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Vector2", 0);
75778     return ;
75779   }
75780   arg2 = *argp2;
75781   {
75782     try {
75783       (arg1)->SetWheelScrollDistanceStep(arg2);
75784     } catch (std::out_of_range& e) {
75785       {
75786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75787       };
75788     } catch (std::exception& e) {
75789       {
75790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75791       };
75792     } catch (Dali::DaliException e) {
75793       {
75794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75795       };
75796     } catch (...) {
75797       {
75798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75799       };
75800     }
75801   }
75802
75803 }
75804
75805
75806 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentScrollPosition(void * jarg1) {
75807   void * jresult ;
75808   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75809   Dali::Vector2 result;
75810
75811   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75812   {
75813     try {
75814       result = ((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentScrollPosition();
75815     } catch (std::out_of_range& e) {
75816       {
75817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75818       };
75819     } catch (std::exception& e) {
75820       {
75821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75822       };
75823     } catch (Dali::DaliException e) {
75824       {
75825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75826       };
75827     } catch (...) {
75828       {
75829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75830       };
75831     }
75832   }
75833
75834   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
75835   return jresult;
75836 }
75837
75838
75839 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_GetCurrentPage(void * jarg1) {
75840   unsigned int jresult ;
75841   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75842   unsigned int result;
75843
75844   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75845   {
75846     try {
75847       result = (unsigned int)((Dali::Toolkit::ScrollView const *)arg1)->GetCurrentPage();
75848     } catch (std::out_of_range& e) {
75849       {
75850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
75851       };
75852     } catch (std::exception& e) {
75853       {
75854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
75855       };
75856     } catch (Dali::DaliException e) {
75857       {
75858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
75859       };
75860     } catch (...) {
75861       {
75862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
75863       };
75864     }
75865   }
75866
75867   jresult = result;
75868   return jresult;
75869 }
75870
75871
75872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_0(void * jarg1, void * jarg2) {
75873   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75874   Dali::Vector2 *arg2 = 0 ;
75875
75876   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75877   arg2 = (Dali::Vector2 *)jarg2;
75878   if (!arg2) {
75879     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75880     return ;
75881   }
75882   {
75883     try {
75884       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2);
75885     } catch (std::out_of_range& e) {
75886       {
75887         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75888       };
75889     } catch (std::exception& e) {
75890       {
75891         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75892       };
75893     } catch (Dali::DaliException e) {
75894       {
75895         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75896       };
75897     } catch (...) {
75898       {
75899         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75900       };
75901     }
75902   }
75903
75904 }
75905
75906
75907 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
75908   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75909   Dali::Vector2 *arg2 = 0 ;
75910   float arg3 ;
75911
75912   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75913   arg2 = (Dali::Vector2 *)jarg2;
75914   if (!arg2) {
75915     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75916     return ;
75917   }
75918   arg3 = (float)jarg3;
75919   {
75920     try {
75921       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3);
75922     } catch (std::out_of_range& e) {
75923       {
75924         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75925       };
75926     } catch (std::exception& e) {
75927       {
75928         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75929       };
75930     } catch (Dali::DaliException e) {
75931       {
75932         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75933       };
75934     } catch (...) {
75935       {
75936         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75937       };
75938     }
75939   }
75940
75941 }
75942
75943
75944 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_2(void * jarg1, void * jarg2, float jarg3, void * jarg4) {
75945   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75946   Dali::Vector2 *arg2 = 0 ;
75947   float arg3 ;
75948   Dali::AlphaFunction arg4 ;
75949   Dali::AlphaFunction *argp4 ;
75950
75951   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75952   arg2 = (Dali::Vector2 *)jarg2;
75953   if (!arg2) {
75954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
75955     return ;
75956   }
75957   arg3 = (float)jarg3;
75958   argp4 = (Dali::AlphaFunction *)jarg4;
75959   if (!argp4) {
75960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
75961     return ;
75962   }
75963   arg4 = *argp4;
75964   {
75965     try {
75966       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4);
75967     } catch (std::out_of_range& e) {
75968       {
75969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
75970       };
75971     } catch (std::exception& e) {
75972       {
75973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
75974       };
75975     } catch (Dali::DaliException e) {
75976       {
75977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
75978       };
75979     } catch (...) {
75980       {
75981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
75982       };
75983     }
75984   }
75985
75986 }
75987
75988
75989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_3(void * jarg1, void * jarg2, float jarg3, int jarg4, int jarg5) {
75990   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
75991   Dali::Vector2 *arg2 = 0 ;
75992   float arg3 ;
75993   Dali::Toolkit::DirectionBias arg4 ;
75994   Dali::Toolkit::DirectionBias arg5 ;
75995
75996   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
75997   arg2 = (Dali::Vector2 *)jarg2;
75998   if (!arg2) {
75999     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76000     return ;
76001   }
76002   arg3 = (float)jarg3;
76003   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76004   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76005   {
76006     try {
76007       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5);
76008     } catch (std::out_of_range& e) {
76009       {
76010         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76011       };
76012     } catch (std::exception& e) {
76013       {
76014         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76015       };
76016     } catch (Dali::DaliException e) {
76017       {
76018         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76019       };
76020     } catch (...) {
76021       {
76022         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76023       };
76024     }
76025   }
76026
76027 }
76028
76029
76030 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_4(void * jarg1, void * jarg2, float jarg3, void * jarg4, int jarg5, int jarg6) {
76031   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76032   Dali::Vector2 *arg2 = 0 ;
76033   float arg3 ;
76034   Dali::AlphaFunction arg4 ;
76035   Dali::Toolkit::DirectionBias arg5 ;
76036   Dali::Toolkit::DirectionBias arg6 ;
76037   Dali::AlphaFunction *argp4 ;
76038
76039   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76040   arg2 = (Dali::Vector2 *)jarg2;
76041   if (!arg2) {
76042     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
76043     return ;
76044   }
76045   arg3 = (float)jarg3;
76046   argp4 = (Dali::AlphaFunction *)jarg4;
76047   if (!argp4) {
76048     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::AlphaFunction", 0);
76049     return ;
76050   }
76051   arg4 = *argp4;
76052   arg5 = (Dali::Toolkit::DirectionBias)jarg5;
76053   arg6 = (Dali::Toolkit::DirectionBias)jarg6;
76054   {
76055     try {
76056       (arg1)->ScrollTo((Dali::Vector2 const &)*arg2,arg3,arg4,arg5,arg6);
76057     } catch (std::out_of_range& e) {
76058       {
76059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76060       };
76061     } catch (std::exception& e) {
76062       {
76063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76064       };
76065     } catch (Dali::DaliException e) {
76066       {
76067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76068       };
76069     } catch (...) {
76070       {
76071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76072       };
76073     }
76074   }
76075
76076 }
76077
76078
76079 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_5(void * jarg1, unsigned int jarg2) {
76080   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76081   unsigned int arg2 ;
76082
76083   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76084   arg2 = (unsigned int)jarg2;
76085   {
76086     try {
76087       (arg1)->ScrollTo(arg2);
76088     } catch (std::out_of_range& e) {
76089       {
76090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76091       };
76092     } catch (std::exception& e) {
76093       {
76094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76095       };
76096     } catch (Dali::DaliException e) {
76097       {
76098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76099       };
76100     } catch (...) {
76101       {
76102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76103       };
76104     }
76105   }
76106
76107 }
76108
76109
76110 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_6(void * jarg1, unsigned int jarg2, float jarg3) {
76111   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76112   unsigned int arg2 ;
76113   float arg3 ;
76114
76115   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76116   arg2 = (unsigned int)jarg2;
76117   arg3 = (float)jarg3;
76118   {
76119     try {
76120       (arg1)->ScrollTo(arg2,arg3);
76121     } catch (std::out_of_range& e) {
76122       {
76123         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76124       };
76125     } catch (std::exception& e) {
76126       {
76127         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76128       };
76129     } catch (Dali::DaliException e) {
76130       {
76131         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76132       };
76133     } catch (...) {
76134       {
76135         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76136       };
76137     }
76138   }
76139
76140 }
76141
76142
76143 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_7(void * jarg1, unsigned int jarg2, float jarg3, int jarg4) {
76144   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76145   unsigned int arg2 ;
76146   float arg3 ;
76147   Dali::Toolkit::DirectionBias arg4 ;
76148
76149   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76150   arg2 = (unsigned int)jarg2;
76151   arg3 = (float)jarg3;
76152   arg4 = (Dali::Toolkit::DirectionBias)jarg4;
76153   {
76154     try {
76155       (arg1)->ScrollTo(arg2,arg3,arg4);
76156     } catch (std::out_of_range& e) {
76157       {
76158         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76159       };
76160     } catch (std::exception& e) {
76161       {
76162         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76163       };
76164     } catch (Dali::DaliException e) {
76165       {
76166         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76167       };
76168     } catch (...) {
76169       {
76170         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76171       };
76172     }
76173   }
76174
76175 }
76176
76177
76178 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_8(void * jarg1, void * jarg2) {
76179   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76180   Dali::Actor *arg2 = 0 ;
76181
76182   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76183   arg2 = (Dali::Actor *)jarg2;
76184   if (!arg2) {
76185     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76186     return ;
76187   }
76188   {
76189     try {
76190       (arg1)->ScrollTo(*arg2);
76191     } catch (std::out_of_range& e) {
76192       {
76193         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76194       };
76195     } catch (std::exception& e) {
76196       {
76197         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76198       };
76199     } catch (Dali::DaliException e) {
76200       {
76201         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76202       };
76203     } catch (...) {
76204       {
76205         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76206       };
76207     }
76208   }
76209
76210 }
76211
76212
76213 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ScrollTo__SWIG_9(void * jarg1, void * jarg2, float jarg3) {
76214   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76215   Dali::Actor *arg2 = 0 ;
76216   float arg3 ;
76217
76218   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76219   arg2 = (Dali::Actor *)jarg2;
76220   if (!arg2) {
76221     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor & type is null", 0);
76222     return ;
76223   }
76224   arg3 = (float)jarg3;
76225   {
76226     try {
76227       (arg1)->ScrollTo(*arg2,arg3);
76228     } catch (std::out_of_range& e) {
76229       {
76230         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76231       };
76232     } catch (std::exception& e) {
76233       {
76234         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76235       };
76236     } catch (Dali::DaliException e) {
76237       {
76238         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76239       };
76240     } catch (...) {
76241       {
76242         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76243       };
76244     }
76245   }
76246
76247 }
76248
76249
76250 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollView_ScrollToSnapPoint(void * jarg1) {
76251   unsigned int jresult ;
76252   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76253   bool result;
76254
76255   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76256   {
76257     try {
76258       result = (bool)(arg1)->ScrollToSnapPoint();
76259     } catch (std::out_of_range& e) {
76260       {
76261         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76262       };
76263     } catch (std::exception& e) {
76264       {
76265         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76266       };
76267     } catch (Dali::DaliException e) {
76268       {
76269         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76270       };
76271     } catch (...) {
76272       {
76273         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76274       };
76275     }
76276   }
76277
76278   jresult = result;
76279   return jresult;
76280 }
76281
76282
76283 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyConstraintToChildren(void * jarg1, void * jarg2) {
76284   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76285   Dali::Constraint arg2 ;
76286   Dali::Constraint *argp2 ;
76287
76288   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76289   argp2 = (Dali::Constraint *)jarg2;
76290   if (!argp2) {
76291     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Constraint", 0);
76292     return ;
76293   }
76294   arg2 = *argp2;
76295   {
76296     try {
76297       (arg1)->ApplyConstraintToChildren(arg2);
76298     } catch (std::out_of_range& e) {
76299       {
76300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76301       };
76302     } catch (std::exception& e) {
76303       {
76304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76305       };
76306     } catch (Dali::DaliException e) {
76307       {
76308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76309       };
76310     } catch (...) {
76311       {
76312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76313       };
76314     }
76315   }
76316
76317 }
76318
76319
76320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveConstraintsFromChildren(void * jarg1) {
76321   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76322
76323   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76324   {
76325     try {
76326       (arg1)->RemoveConstraintsFromChildren();
76327     } catch (std::out_of_range& e) {
76328       {
76329         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76330       };
76331     } catch (std::exception& e) {
76332       {
76333         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76334       };
76335     } catch (Dali::DaliException e) {
76336       {
76337         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76338       };
76339     } catch (...) {
76340       {
76341         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76342       };
76343     }
76344   }
76345
76346 }
76347
76348
76349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_ApplyEffect(void * jarg1, void * jarg2) {
76350   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76351   Dali::Toolkit::ScrollViewEffect arg2 ;
76352   Dali::Toolkit::ScrollViewEffect *argp2 ;
76353
76354   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76355   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76356   if (!argp2) {
76357     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76358     return ;
76359   }
76360   arg2 = *argp2;
76361   {
76362     try {
76363       (arg1)->ApplyEffect(arg2);
76364     } catch (std::out_of_range& e) {
76365       {
76366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76367       };
76368     } catch (std::exception& e) {
76369       {
76370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76371       };
76372     } catch (Dali::DaliException e) {
76373       {
76374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76375       };
76376     } catch (...) {
76377       {
76378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76379       };
76380     }
76381   }
76382
76383 }
76384
76385
76386 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveEffect(void * jarg1, void * jarg2) {
76387   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76388   Dali::Toolkit::ScrollViewEffect arg2 ;
76389   Dali::Toolkit::ScrollViewEffect *argp2 ;
76390
76391   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76392   argp2 = (Dali::Toolkit::ScrollViewEffect *)jarg2;
76393   if (!argp2) {
76394     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ScrollViewEffect", 0);
76395     return ;
76396   }
76397   arg2 = *argp2;
76398   {
76399     try {
76400       (arg1)->RemoveEffect(arg2);
76401     } catch (std::out_of_range& e) {
76402       {
76403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76404       };
76405     } catch (std::exception& e) {
76406       {
76407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76408       };
76409     } catch (Dali::DaliException e) {
76410       {
76411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76412       };
76413     } catch (...) {
76414       {
76415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76416       };
76417     }
76418   }
76419
76420 }
76421
76422
76423 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveAllEffects(void * jarg1) {
76424   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76425
76426   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76427   {
76428     try {
76429       (arg1)->RemoveAllEffects();
76430     } catch (std::out_of_range& e) {
76431       {
76432         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76433       };
76434     } catch (std::exception& e) {
76435       {
76436         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76437       };
76438     } catch (Dali::DaliException e) {
76439       {
76440         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76441       };
76442     } catch (...) {
76443       {
76444         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76445       };
76446     }
76447   }
76448
76449 }
76450
76451
76452 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_BindActor(void * jarg1, void * jarg2) {
76453   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76454   Dali::Actor arg2 ;
76455   Dali::Actor *argp2 ;
76456
76457   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76458   argp2 = (Dali::Actor *)jarg2;
76459   if (!argp2) {
76460     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76461     return ;
76462   }
76463   arg2 = *argp2;
76464   {
76465     try {
76466       (arg1)->BindActor(arg2);
76467     } catch (std::out_of_range& e) {
76468       {
76469         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76470       };
76471     } catch (std::exception& e) {
76472       {
76473         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76474       };
76475     } catch (Dali::DaliException e) {
76476       {
76477         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76478       };
76479     } catch (...) {
76480       {
76481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76482       };
76483     }
76484   }
76485
76486 }
76487
76488
76489 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_UnbindActor(void * jarg1, void * jarg2) {
76490   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76491   Dali::Actor arg2 ;
76492   Dali::Actor *argp2 ;
76493
76494   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76495   argp2 = (Dali::Actor *)jarg2;
76496   if (!argp2) {
76497     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
76498     return ;
76499   }
76500   arg2 = *argp2;
76501   {
76502     try {
76503       (arg1)->UnbindActor(arg2);
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_SetScrollingDirection__SWIG_0(void * jarg1, void * jarg2, void * jarg3) {
76527   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76528   Dali::Radian arg2 ;
76529   Dali::Radian arg3 ;
76530   Dali::Radian *argp2 ;
76531   Dali::Radian *argp3 ;
76532
76533   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76534   argp2 = (Dali::Radian *)jarg2;
76535   if (!argp2) {
76536     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76537     return ;
76538   }
76539   arg2 = *argp2;
76540   argp3 = (Dali::Radian *)jarg3;
76541   if (!argp3) {
76542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76543     return ;
76544   }
76545   arg3 = *argp3;
76546   {
76547     try {
76548       (arg1)->SetScrollingDirection(arg2,arg3);
76549     } catch (std::out_of_range& e) {
76550       {
76551         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76552       };
76553     } catch (std::exception& e) {
76554       {
76555         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76556       };
76557     } catch (Dali::DaliException e) {
76558       {
76559         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76560       };
76561     } catch (...) {
76562       {
76563         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76564       };
76565     }
76566   }
76567
76568 }
76569
76570
76571 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_SetScrollingDirection__SWIG_1(void * jarg1, void * jarg2) {
76572   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76573   Dali::Radian arg2 ;
76574   Dali::Radian *argp2 ;
76575
76576   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76577   argp2 = (Dali::Radian *)jarg2;
76578   if (!argp2) {
76579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76580     return ;
76581   }
76582   arg2 = *argp2;
76583   {
76584     try {
76585       (arg1)->SetScrollingDirection(arg2);
76586     } catch (std::out_of_range& e) {
76587       {
76588         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76589       };
76590     } catch (std::exception& e) {
76591       {
76592         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76593       };
76594     } catch (Dali::DaliException e) {
76595       {
76596         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76597       };
76598     } catch (...) {
76599       {
76600         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76601       };
76602     }
76603   }
76604
76605 }
76606
76607
76608 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollView_RemoveScrollingDirection(void * jarg1, void * jarg2) {
76609   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76610   Dali::Radian arg2 ;
76611   Dali::Radian *argp2 ;
76612
76613   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76614   argp2 = (Dali::Radian *)jarg2;
76615   if (!argp2) {
76616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Radian", 0);
76617     return ;
76618   }
76619   arg2 = *argp2;
76620   {
76621     try {
76622       (arg1)->RemoveScrollingDirection(arg2);
76623     } catch (std::out_of_range& e) {
76624       {
76625         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76626       };
76627     } catch (std::exception& e) {
76628       {
76629         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76630       };
76631     } catch (Dali::DaliException e) {
76632       {
76633         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76634       };
76635     } catch (...) {
76636       {
76637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76638       };
76639     }
76640   }
76641
76642 }
76643
76644
76645 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ScrollView_SnapStartedSignal(void * jarg1) {
76646   void * jresult ;
76647   Dali::Toolkit::ScrollView *arg1 = (Dali::Toolkit::ScrollView *) 0 ;
76648   Dali::Toolkit::ScrollView::SnapStartedSignalType *result = 0 ;
76649
76650   arg1 = (Dali::Toolkit::ScrollView *)jarg1;
76651   {
76652     try {
76653       result = (Dali::Toolkit::ScrollView::SnapStartedSignalType *) &(arg1)->SnapStartedSignal();
76654     } catch (std::out_of_range& e) {
76655       {
76656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76657       };
76658     } catch (std::exception& e) {
76659       {
76660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76661       };
76662     } catch (Dali::DaliException e) {
76663       {
76664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76665       };
76666     } catch (...) {
76667       {
76668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76669       };
76670     }
76671   }
76672
76673   jresult = (void *)result;
76674   return jresult;
76675 }
76676
76677
76678 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_ROWS_get() {
76679   int jresult ;
76680   int result;
76681
76682   result = (int)Dali::Toolkit::TableView::Property::ROWS;
76683   jresult = (int)result;
76684   return jresult;
76685 }
76686
76687
76688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_COLUMNS_get() {
76689   int jresult ;
76690   int result;
76691
76692   result = (int)Dali::Toolkit::TableView::Property::COLUMNS;
76693   jresult = (int)result;
76694   return jresult;
76695 }
76696
76697
76698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_CELL_PADDING_get() {
76699   int jresult ;
76700   int result;
76701
76702   result = (int)Dali::Toolkit::TableView::Property::CELL_PADDING;
76703   jresult = (int)result;
76704   return jresult;
76705 }
76706
76707
76708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_ROWS_get() {
76709   int jresult ;
76710   int result;
76711
76712   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_ROWS;
76713   jresult = (int)result;
76714   return jresult;
76715 }
76716
76717
76718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_Property_LAYOUT_COLUMNS_get() {
76719   int jresult ;
76720   int result;
76721
76722   result = (int)Dali::Toolkit::TableView::Property::LAYOUT_COLUMNS;
76723   jresult = (int)result;
76724   return jresult;
76725 }
76726
76727
76728 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_Property() {
76729   void * jresult ;
76730   Dali::Toolkit::TableView::Property *result = 0 ;
76731
76732   {
76733     try {
76734       result = (Dali::Toolkit::TableView::Property *)new Dali::Toolkit::TableView::Property();
76735     } catch (std::out_of_range& e) {
76736       {
76737         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76738       };
76739     } catch (std::exception& e) {
76740       {
76741         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76742       };
76743     } catch (Dali::DaliException e) {
76744       {
76745         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76746       };
76747     } catch (...) {
76748       {
76749         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76750       };
76751     }
76752   }
76753
76754   jresult = (void *)result;
76755   return jresult;
76756 }
76757
76758
76759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_Property(void * jarg1) {
76760   Dali::Toolkit::TableView::Property *arg1 = (Dali::Toolkit::TableView::Property *) 0 ;
76761
76762   arg1 = (Dali::Toolkit::TableView::Property *)jarg1;
76763   {
76764     try {
76765       delete arg1;
76766     } catch (std::out_of_range& e) {
76767       {
76768         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76769       };
76770     } catch (std::exception& e) {
76771       {
76772         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76773       };
76774     } catch (Dali::DaliException e) {
76775       {
76776         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76777       };
76778     } catch (...) {
76779       {
76780         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76781       };
76782     }
76783   }
76784
76785 }
76786
76787
76788 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_INDEX_get() {
76789   int jresult ;
76790   int result;
76791
76792   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_INDEX;
76793   jresult = (int)result;
76794   return jresult;
76795 }
76796
76797
76798 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_ROW_SPAN_get() {
76799   int jresult ;
76800   int result;
76801
76802   result = (int)Dali::Toolkit::TableView::ChildProperty::ROW_SPAN;
76803   jresult = (int)result;
76804   return jresult;
76805 }
76806
76807
76808 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_COLUMN_SPAN_get() {
76809   int jresult ;
76810   int result;
76811
76812   result = (int)Dali::Toolkit::TableView::ChildProperty::COLUMN_SPAN;
76813   jresult = (int)result;
76814   return jresult;
76815 }
76816
76817
76818 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_HORIZONTAL_ALIGNMENT_get() {
76819   int jresult ;
76820   int result;
76821
76822   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_HORIZONTAL_ALIGNMENT;
76823   jresult = (int)result;
76824   return jresult;
76825 }
76826
76827
76828 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TableView_ChildProperty_CELL_VERTICAL_ALIGNMENT_get() {
76829   int jresult ;
76830   int result;
76831
76832   result = (int)Dali::Toolkit::TableView::ChildProperty::CELL_VERTICAL_ALIGNMENT;
76833   jresult = (int)result;
76834   return jresult;
76835 }
76836
76837
76838 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_ChildProperty() {
76839   void * jresult ;
76840   Dali::Toolkit::TableView::ChildProperty *result = 0 ;
76841
76842   {
76843     try {
76844       result = (Dali::Toolkit::TableView::ChildProperty *)new Dali::Toolkit::TableView::ChildProperty();
76845     } catch (std::out_of_range& e) {
76846       {
76847         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76848       };
76849     } catch (std::exception& e) {
76850       {
76851         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76852       };
76853     } catch (Dali::DaliException e) {
76854       {
76855         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76856       };
76857     } catch (...) {
76858       {
76859         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76860       };
76861     }
76862   }
76863
76864   jresult = (void *)result;
76865   return jresult;
76866 }
76867
76868
76869 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_ChildProperty(void * jarg1) {
76870   Dali::Toolkit::TableView::ChildProperty *arg1 = (Dali::Toolkit::TableView::ChildProperty *) 0 ;
76871
76872   arg1 = (Dali::Toolkit::TableView::ChildProperty *)jarg1;
76873   {
76874     try {
76875       delete arg1;
76876     } catch (std::out_of_range& e) {
76877       {
76878         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
76879       };
76880     } catch (std::exception& e) {
76881       {
76882         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
76883       };
76884     } catch (Dali::DaliException e) {
76885       {
76886         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
76887       };
76888     } catch (...) {
76889       {
76890         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
76891       };
76892     }
76893   }
76894
76895 }
76896
76897
76898 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_0(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3, unsigned int jarg4) {
76899   void * jresult ;
76900   unsigned int arg1 ;
76901   unsigned int arg2 ;
76902   unsigned int arg3 ;
76903   unsigned int arg4 ;
76904   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76905
76906   arg1 = (unsigned int)jarg1;
76907   arg2 = (unsigned int)jarg2;
76908   arg3 = (unsigned int)jarg3;
76909   arg4 = (unsigned int)jarg4;
76910   {
76911     try {
76912       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3,arg4);
76913     } catch (std::out_of_range& e) {
76914       {
76915         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76916       };
76917     } catch (std::exception& e) {
76918       {
76919         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76920       };
76921     } catch (Dali::DaliException e) {
76922       {
76923         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76924       };
76925     } catch (...) {
76926       {
76927         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76928       };
76929     }
76930   }
76931
76932   jresult = (void *)result;
76933   return jresult;
76934 }
76935
76936
76937 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_1(unsigned int jarg1, unsigned int jarg2, unsigned int jarg3) {
76938   void * jresult ;
76939   unsigned int arg1 ;
76940   unsigned int arg2 ;
76941   unsigned int arg3 ;
76942   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76943
76944   arg1 = (unsigned int)jarg1;
76945   arg2 = (unsigned int)jarg2;
76946   arg3 = (unsigned int)jarg3;
76947   {
76948     try {
76949       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2,arg3);
76950     } catch (std::out_of_range& e) {
76951       {
76952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76953       };
76954     } catch (std::exception& e) {
76955       {
76956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76957       };
76958     } catch (Dali::DaliException e) {
76959       {
76960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76961       };
76962     } catch (...) {
76963       {
76964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
76965       };
76966     }
76967   }
76968
76969   jresult = (void *)result;
76970   return jresult;
76971 }
76972
76973
76974 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_2(unsigned int jarg1, unsigned int jarg2) {
76975   void * jresult ;
76976   unsigned int arg1 ;
76977   unsigned int arg2 ;
76978   Dali::Toolkit::TableView::CellPosition *result = 0 ;
76979
76980   arg1 = (unsigned int)jarg1;
76981   arg2 = (unsigned int)jarg2;
76982   {
76983     try {
76984       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1,arg2);
76985     } catch (std::out_of_range& e) {
76986       {
76987         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
76988       };
76989     } catch (std::exception& e) {
76990       {
76991         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
76992       };
76993     } catch (Dali::DaliException e) {
76994       {
76995         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
76996       };
76997     } catch (...) {
76998       {
76999         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77000       };
77001     }
77002   }
77003
77004   jresult = (void *)result;
77005   return jresult;
77006 }
77007
77008
77009 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_3(unsigned int jarg1) {
77010   void * jresult ;
77011   unsigned int arg1 ;
77012   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77013
77014   arg1 = (unsigned int)jarg1;
77015   {
77016     try {
77017       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition(arg1);
77018     } catch (std::out_of_range& e) {
77019       {
77020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77021       };
77022     } catch (std::exception& e) {
77023       {
77024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77025       };
77026     } catch (Dali::DaliException e) {
77027       {
77028         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77029       };
77030     } catch (...) {
77031       {
77032         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77033       };
77034     }
77035   }
77036
77037   jresult = (void *)result;
77038   return jresult;
77039 }
77040
77041
77042 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView_CellPosition__SWIG_4() {
77043   void * jresult ;
77044   Dali::Toolkit::TableView::CellPosition *result = 0 ;
77045
77046   {
77047     try {
77048       result = (Dali::Toolkit::TableView::CellPosition *)new Dali::Toolkit::TableView::CellPosition();
77049     } catch (std::out_of_range& e) {
77050       {
77051         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77052       };
77053     } catch (std::exception& e) {
77054       {
77055         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77056       };
77057     } catch (Dali::DaliException e) {
77058       {
77059         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77060       };
77061     } catch (...) {
77062       {
77063         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77064       };
77065     }
77066   }
77067
77068   jresult = (void *)result;
77069   return jresult;
77070 }
77071
77072
77073 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_set(void * jarg1, unsigned int jarg2) {
77074   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77075   unsigned int arg2 ;
77076
77077   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77078   arg2 = (unsigned int)jarg2;
77079   if (arg1) (arg1)->rowIndex = arg2;
77080 }
77081
77082
77083 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowIndex_get(void * jarg1) {
77084   unsigned int jresult ;
77085   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77086   unsigned int result;
77087
77088   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77089   result = (unsigned int) ((arg1)->rowIndex);
77090   jresult = result;
77091   return jresult;
77092 }
77093
77094
77095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_set(void * jarg1, unsigned int jarg2) {
77096   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77097   unsigned int arg2 ;
77098
77099   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77100   arg2 = (unsigned int)jarg2;
77101   if (arg1) (arg1)->columnIndex = arg2;
77102 }
77103
77104
77105 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnIndex_get(void * jarg1) {
77106   unsigned int jresult ;
77107   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77108   unsigned int result;
77109
77110   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77111   result = (unsigned int) ((arg1)->columnIndex);
77112   jresult = result;
77113   return jresult;
77114 }
77115
77116
77117 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_set(void * jarg1, unsigned int jarg2) {
77118   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77119   unsigned int arg2 ;
77120
77121   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77122   arg2 = (unsigned int)jarg2;
77123   if (arg1) (arg1)->rowSpan = arg2;
77124 }
77125
77126
77127 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_rowSpan_get(void * jarg1) {
77128   unsigned int jresult ;
77129   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77130   unsigned int result;
77131
77132   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77133   result = (unsigned int) ((arg1)->rowSpan);
77134   jresult = result;
77135   return jresult;
77136 }
77137
77138
77139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_set(void * jarg1, unsigned int jarg2) {
77140   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77141   unsigned int arg2 ;
77142
77143   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77144   arg2 = (unsigned int)jarg2;
77145   if (arg1) (arg1)->columnSpan = arg2;
77146 }
77147
77148
77149 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_CellPosition_columnSpan_get(void * jarg1) {
77150   unsigned int jresult ;
77151   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77152   unsigned int result;
77153
77154   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77155   result = (unsigned int) ((arg1)->columnSpan);
77156   jresult = result;
77157   return jresult;
77158 }
77159
77160
77161 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView_CellPosition(void * jarg1) {
77162   Dali::Toolkit::TableView::CellPosition *arg1 = (Dali::Toolkit::TableView::CellPosition *) 0 ;
77163
77164   arg1 = (Dali::Toolkit::TableView::CellPosition *)jarg1;
77165   {
77166     try {
77167       delete arg1;
77168     } catch (std::out_of_range& e) {
77169       {
77170         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77171       };
77172     } catch (std::exception& e) {
77173       {
77174         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77175       };
77176     } catch (Dali::DaliException e) {
77177       {
77178         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77179       };
77180     } catch (...) {
77181       {
77182         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77183       };
77184     }
77185   }
77186
77187 }
77188
77189
77190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_0() {
77191   void * jresult ;
77192   Dali::Toolkit::TableView *result = 0 ;
77193
77194   {
77195     try {
77196       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView();
77197     } catch (std::out_of_range& e) {
77198       {
77199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77200       };
77201     } catch (std::exception& e) {
77202       {
77203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77204       };
77205     } catch (Dali::DaliException e) {
77206       {
77207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77208       };
77209     } catch (...) {
77210       {
77211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77212       };
77213     }
77214   }
77215
77216   jresult = (void *)result;
77217   return jresult;
77218 }
77219
77220
77221 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TableView__SWIG_1(void * jarg1) {
77222   void * jresult ;
77223   Dali::Toolkit::TableView *arg1 = 0 ;
77224   Dali::Toolkit::TableView *result = 0 ;
77225
77226   arg1 = (Dali::Toolkit::TableView *)jarg1;
77227   if (!arg1) {
77228     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77229     return 0;
77230   }
77231   {
77232     try {
77233       result = (Dali::Toolkit::TableView *)new Dali::Toolkit::TableView((Dali::Toolkit::TableView const &)*arg1);
77234     } catch (std::out_of_range& e) {
77235       {
77236         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77237       };
77238     } catch (std::exception& e) {
77239       {
77240         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77241       };
77242     } catch (Dali::DaliException e) {
77243       {
77244         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77245       };
77246     } catch (...) {
77247       {
77248         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77249       };
77250     }
77251   }
77252
77253   jresult = (void *)result;
77254   return jresult;
77255 }
77256
77257
77258 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_Assign(void * jarg1, void * jarg2) {
77259   void * jresult ;
77260   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77261   Dali::Toolkit::TableView *arg2 = 0 ;
77262   Dali::Toolkit::TableView *result = 0 ;
77263
77264   arg1 = (Dali::Toolkit::TableView *)jarg1;
77265   arg2 = (Dali::Toolkit::TableView *)jarg2;
77266   if (!arg2) {
77267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView const & type is null", 0);
77268     return 0;
77269   }
77270   {
77271     try {
77272       result = (Dali::Toolkit::TableView *) &(arg1)->operator =((Dali::Toolkit::TableView const &)*arg2);
77273     } catch (std::out_of_range& e) {
77274       {
77275         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77276       };
77277     } catch (std::exception& e) {
77278       {
77279         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77280       };
77281     } catch (Dali::DaliException e) {
77282       {
77283         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77284       };
77285     } catch (...) {
77286       {
77287         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77288       };
77289     }
77290   }
77291
77292   jresult = (void *)result;
77293   return jresult;
77294 }
77295
77296
77297 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TableView(void * jarg1) {
77298   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77299
77300   arg1 = (Dali::Toolkit::TableView *)jarg1;
77301   {
77302     try {
77303       delete arg1;
77304     } catch (std::out_of_range& e) {
77305       {
77306         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77307       };
77308     } catch (std::exception& e) {
77309       {
77310         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77311       };
77312     } catch (Dali::DaliException e) {
77313       {
77314         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77315       };
77316     } catch (...) {
77317       {
77318         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77319       };
77320     }
77321   }
77322
77323 }
77324
77325
77326 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_New(unsigned int jarg1, unsigned int jarg2) {
77327   void * jresult ;
77328   unsigned int arg1 ;
77329   unsigned int arg2 ;
77330   Dali::Toolkit::TableView result;
77331
77332   arg1 = (unsigned int)jarg1;
77333   arg2 = (unsigned int)jarg2;
77334   {
77335     try {
77336       result = Dali::Toolkit::TableView::New(arg1,arg2);
77337     } catch (std::out_of_range& e) {
77338       {
77339         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77340       };
77341     } catch (std::exception& e) {
77342       {
77343         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77344       };
77345     } catch (Dali::DaliException e) {
77346       {
77347         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77348       };
77349     } catch (...) {
77350       {
77351         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77352       };
77353     }
77354   }
77355
77356   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77357   return jresult;
77358 }
77359
77360
77361 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_DownCast(void * jarg1) {
77362   void * jresult ;
77363   Dali::BaseHandle arg1 ;
77364   Dali::BaseHandle *argp1 ;
77365   Dali::Toolkit::TableView result;
77366
77367   argp1 = (Dali::BaseHandle *)jarg1;
77368   if (!argp1) {
77369     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
77370     return 0;
77371   }
77372   arg1 = *argp1;
77373   {
77374     try {
77375       result = Dali::Toolkit::TableView::DownCast(arg1);
77376     } catch (std::out_of_range& e) {
77377       {
77378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77379       };
77380     } catch (std::exception& e) {
77381       {
77382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77383       };
77384     } catch (Dali::DaliException e) {
77385       {
77386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77387       };
77388     } catch (...) {
77389       {
77390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77391       };
77392     }
77393   }
77394
77395   jresult = new Dali::Toolkit::TableView((const Dali::Toolkit::TableView &)result);
77396   return jresult;
77397 }
77398
77399
77400 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_AddChild(void * jarg1, void * jarg2, void * jarg3) {
77401   unsigned int jresult ;
77402   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77403   Dali::Actor arg2 ;
77404   Dali::Toolkit::TableView::CellPosition arg3 ;
77405   Dali::Actor *argp2 ;
77406   Dali::Toolkit::TableView::CellPosition *argp3 ;
77407   bool result;
77408
77409   arg1 = (Dali::Toolkit::TableView *)jarg1;
77410   argp2 = (Dali::Actor *)jarg2;
77411   if (!argp2) {
77412     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77413     return 0;
77414   }
77415   arg2 = *argp2;
77416   argp3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77417   if (!argp3) {
77418     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77419     return 0;
77420   }
77421   arg3 = *argp3;
77422   {
77423     try {
77424       result = (bool)(arg1)->AddChild(arg2,arg3);
77425     } catch (std::out_of_range& e) {
77426       {
77427         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77428       };
77429     } catch (std::exception& e) {
77430       {
77431         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77432       };
77433     } catch (Dali::DaliException e) {
77434       {
77435         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77436       };
77437     } catch (...) {
77438       {
77439         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77440       };
77441     }
77442   }
77443
77444   jresult = result;
77445   return jresult;
77446 }
77447
77448
77449 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetChildAt(void * jarg1, void * jarg2) {
77450   void * jresult ;
77451   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77452   Dali::Toolkit::TableView::CellPosition arg2 ;
77453   Dali::Toolkit::TableView::CellPosition *argp2 ;
77454   Dali::Actor result;
77455
77456   arg1 = (Dali::Toolkit::TableView *)jarg1;
77457   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77458   if (!argp2) {
77459     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77460     return 0;
77461   }
77462   arg2 = *argp2;
77463   {
77464     try {
77465       result = (arg1)->GetChildAt(arg2);
77466     } catch (std::out_of_range& e) {
77467       {
77468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77469       };
77470     } catch (std::exception& e) {
77471       {
77472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77473       };
77474     } catch (Dali::DaliException e) {
77475       {
77476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77477       };
77478     } catch (...) {
77479       {
77480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77481       };
77482     }
77483   }
77484
77485   jresult = new Dali::Actor((const Dali::Actor &)result);
77486   return jresult;
77487 }
77488
77489
77490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_RemoveChildAt(void * jarg1, void * jarg2) {
77491   void * jresult ;
77492   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77493   Dali::Toolkit::TableView::CellPosition arg2 ;
77494   Dali::Toolkit::TableView::CellPosition *argp2 ;
77495   Dali::Actor result;
77496
77497   arg1 = (Dali::Toolkit::TableView *)jarg1;
77498   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
77499   if (!argp2) {
77500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
77501     return 0;
77502   }
77503   arg2 = *argp2;
77504   {
77505     try {
77506       result = (arg1)->RemoveChildAt(arg2);
77507     } catch (std::out_of_range& e) {
77508       {
77509         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77510       };
77511     } catch (std::exception& e) {
77512       {
77513         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77514       };
77515     } catch (Dali::DaliException e) {
77516       {
77517         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77518       };
77519     } catch (...) {
77520       {
77521         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77522       };
77523     }
77524   }
77525
77526   jresult = new Dali::Actor((const Dali::Actor &)result);
77527   return jresult;
77528 }
77529
77530
77531 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_FindChildPosition(void * jarg1, void * jarg2, void * jarg3) {
77532   unsigned int jresult ;
77533   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77534   Dali::Actor arg2 ;
77535   Dali::Toolkit::TableView::CellPosition *arg3 = 0 ;
77536   Dali::Actor *argp2 ;
77537   bool result;
77538
77539   arg1 = (Dali::Toolkit::TableView *)jarg1;
77540   argp2 = (Dali::Actor *)jarg2;
77541   if (!argp2) {
77542     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
77543     return 0;
77544   }
77545   arg2 = *argp2;
77546   arg3 = (Dali::Toolkit::TableView::CellPosition *)jarg3;
77547   if (!arg3) {
77548     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TableView::CellPosition & type is null", 0);
77549     return 0;
77550   }
77551   {
77552     try {
77553       result = (bool)(arg1)->FindChildPosition(arg2,*arg3);
77554     } catch (std::out_of_range& e) {
77555       {
77556         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77557       };
77558     } catch (std::exception& e) {
77559       {
77560         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77561       };
77562     } catch (Dali::DaliException e) {
77563       {
77564         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77565       };
77566     } catch (...) {
77567       {
77568         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77569       };
77570     }
77571   }
77572
77573   jresult = result;
77574   return jresult;
77575 }
77576
77577
77578 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertRow(void * jarg1, unsigned int jarg2) {
77579   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77580   unsigned int arg2 ;
77581
77582   arg1 = (Dali::Toolkit::TableView *)jarg1;
77583   arg2 = (unsigned int)jarg2;
77584   {
77585     try {
77586       (arg1)->InsertRow(arg2);
77587     } catch (std::out_of_range& e) {
77588       {
77589         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77590       };
77591     } catch (std::exception& e) {
77592       {
77593         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77594       };
77595     } catch (Dali::DaliException e) {
77596       {
77597         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77598       };
77599     } catch (...) {
77600       {
77601         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77602       };
77603     }
77604   }
77605
77606 }
77607
77608
77609 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_0(void * jarg1, unsigned int jarg2) {
77610   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77611   unsigned int arg2 ;
77612
77613   arg1 = (Dali::Toolkit::TableView *)jarg1;
77614   arg2 = (unsigned int)jarg2;
77615   {
77616     try {
77617       (arg1)->DeleteRow(arg2);
77618     } catch (std::out_of_range& e) {
77619       {
77620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77621       };
77622     } catch (std::exception& e) {
77623       {
77624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77625       };
77626     } catch (Dali::DaliException e) {
77627       {
77628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77629       };
77630     } catch (...) {
77631       {
77632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77633       };
77634     }
77635   }
77636
77637 }
77638
77639
77640 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteRow__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77641   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77642   unsigned int arg2 ;
77643   std::vector< Dali::Actor > *arg3 = 0 ;
77644
77645   arg1 = (Dali::Toolkit::TableView *)jarg1;
77646   arg2 = (unsigned int)jarg2;
77647   arg3 = (std::vector< Dali::Actor > *)jarg3;
77648   if (!arg3) {
77649     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77650     return ;
77651   }
77652   {
77653     try {
77654       (arg1)->DeleteRow(arg2,*arg3);
77655     } catch (std::out_of_range& e) {
77656       {
77657         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77658       };
77659     } catch (std::exception& e) {
77660       {
77661         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77662       };
77663     } catch (Dali::DaliException e) {
77664       {
77665         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77666       };
77667     } catch (...) {
77668       {
77669         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77670       };
77671     }
77672   }
77673
77674 }
77675
77676
77677 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_InsertColumn(void * jarg1, unsigned int jarg2) {
77678   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77679   unsigned int arg2 ;
77680
77681   arg1 = (Dali::Toolkit::TableView *)jarg1;
77682   arg2 = (unsigned int)jarg2;
77683   {
77684     try {
77685       (arg1)->InsertColumn(arg2);
77686     } catch (std::out_of_range& e) {
77687       {
77688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77689       };
77690     } catch (std::exception& e) {
77691       {
77692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77693       };
77694     } catch (Dali::DaliException e) {
77695       {
77696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77697       };
77698     } catch (...) {
77699       {
77700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77701       };
77702     }
77703   }
77704
77705 }
77706
77707
77708 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_0(void * jarg1, unsigned int jarg2) {
77709   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77710   unsigned int arg2 ;
77711
77712   arg1 = (Dali::Toolkit::TableView *)jarg1;
77713   arg2 = (unsigned int)jarg2;
77714   {
77715     try {
77716       (arg1)->DeleteColumn(arg2);
77717     } catch (std::out_of_range& e) {
77718       {
77719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77720       };
77721     } catch (std::exception& e) {
77722       {
77723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77724       };
77725     } catch (Dali::DaliException e) {
77726       {
77727         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77728       };
77729     } catch (...) {
77730       {
77731         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77732       };
77733     }
77734   }
77735
77736 }
77737
77738
77739 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_DeleteColumn__SWIG_1(void * jarg1, unsigned int jarg2, void * jarg3) {
77740   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77741   unsigned int arg2 ;
77742   std::vector< Dali::Actor > *arg3 = 0 ;
77743
77744   arg1 = (Dali::Toolkit::TableView *)jarg1;
77745   arg2 = (unsigned int)jarg2;
77746   arg3 = (std::vector< Dali::Actor > *)jarg3;
77747   if (!arg3) {
77748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77749     return ;
77750   }
77751   {
77752     try {
77753       (arg1)->DeleteColumn(arg2,*arg3);
77754     } catch (std::out_of_range& e) {
77755       {
77756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77757       };
77758     } catch (std::exception& e) {
77759       {
77760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77761       };
77762     } catch (Dali::DaliException e) {
77763       {
77764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77765       };
77766     } catch (...) {
77767       {
77768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77769       };
77770     }
77771   }
77772
77773 }
77774
77775
77776 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_0(void * jarg1, unsigned int jarg2, unsigned int jarg3) {
77777   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77778   unsigned int arg2 ;
77779   unsigned int arg3 ;
77780
77781   arg1 = (Dali::Toolkit::TableView *)jarg1;
77782   arg2 = (unsigned int)jarg2;
77783   arg3 = (unsigned int)jarg3;
77784   {
77785     try {
77786       (arg1)->Resize(arg2,arg3);
77787     } catch (std::out_of_range& e) {
77788       {
77789         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77790       };
77791     } catch (std::exception& e) {
77792       {
77793         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77794       };
77795     } catch (Dali::DaliException e) {
77796       {
77797         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77798       };
77799     } catch (...) {
77800       {
77801         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77802       };
77803     }
77804   }
77805
77806 }
77807
77808
77809 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_Resize__SWIG_1(void * jarg1, unsigned int jarg2, unsigned int jarg3, void * jarg4) {
77810   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77811   unsigned int arg2 ;
77812   unsigned int arg3 ;
77813   std::vector< Dali::Actor > *arg4 = 0 ;
77814
77815   arg1 = (Dali::Toolkit::TableView *)jarg1;
77816   arg2 = (unsigned int)jarg2;
77817   arg3 = (unsigned int)jarg3;
77818   arg4 = (std::vector< Dali::Actor > *)jarg4;
77819   if (!arg4) {
77820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > & type is null", 0);
77821     return ;
77822   }
77823   {
77824     try {
77825       (arg1)->Resize(arg2,arg3,*arg4);
77826     } catch (std::out_of_range& e) {
77827       {
77828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77829       };
77830     } catch (std::exception& e) {
77831       {
77832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77833       };
77834     } catch (Dali::DaliException e) {
77835       {
77836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77837       };
77838     } catch (...) {
77839       {
77840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77841       };
77842     }
77843   }
77844
77845 }
77846
77847
77848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellPadding(void * jarg1, void * jarg2) {
77849   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77850   Dali::Size arg2 ;
77851   Dali::Size *argp2 ;
77852
77853   arg1 = (Dali::Toolkit::TableView *)jarg1;
77854   argp2 = (Dali::Size *)jarg2;
77855   if (!argp2) {
77856     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
77857     return ;
77858   }
77859   arg2 = *argp2;
77860   {
77861     try {
77862       (arg1)->SetCellPadding(arg2);
77863     } catch (std::out_of_range& e) {
77864       {
77865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77866       };
77867     } catch (std::exception& e) {
77868       {
77869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77870       };
77871     } catch (Dali::DaliException e) {
77872       {
77873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77874       };
77875     } catch (...) {
77876       {
77877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77878       };
77879     }
77880   }
77881
77882 }
77883
77884
77885 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TableView_GetCellPadding(void * jarg1) {
77886   void * jresult ;
77887   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77888   Dali::Size result;
77889
77890   arg1 = (Dali::Toolkit::TableView *)jarg1;
77891   {
77892     try {
77893       result = (arg1)->GetCellPadding();
77894     } catch (std::out_of_range& e) {
77895       {
77896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77897       };
77898     } catch (std::exception& e) {
77899       {
77900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77901       };
77902     } catch (Dali::DaliException e) {
77903       {
77904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77905       };
77906     } catch (...) {
77907       {
77908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77909       };
77910     }
77911   }
77912
77913   jresult = new Dali::Size((const Dali::Size &)result);
77914   return jresult;
77915 }
77916
77917
77918 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitHeight(void * jarg1, unsigned int jarg2) {
77919   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77920   unsigned int arg2 ;
77921
77922   arg1 = (Dali::Toolkit::TableView *)jarg1;
77923   arg2 = (unsigned int)jarg2;
77924   {
77925     try {
77926       (arg1)->SetFitHeight(arg2);
77927     } catch (std::out_of_range& e) {
77928       {
77929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77930       };
77931     } catch (std::exception& e) {
77932       {
77933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
77934       };
77935     } catch (Dali::DaliException e) {
77936       {
77937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
77938       };
77939     } catch (...) {
77940       {
77941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
77942       };
77943     }
77944   }
77945
77946 }
77947
77948
77949 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitHeight(void * jarg1, unsigned int jarg2) {
77950   unsigned int jresult ;
77951   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77952   unsigned int arg2 ;
77953   bool result;
77954
77955   arg1 = (Dali::Toolkit::TableView *)jarg1;
77956   arg2 = (unsigned int)jarg2;
77957   {
77958     try {
77959       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitHeight(arg2);
77960     } catch (std::out_of_range& e) {
77961       {
77962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
77963       };
77964     } catch (std::exception& e) {
77965       {
77966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
77967       };
77968     } catch (Dali::DaliException e) {
77969       {
77970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
77971       };
77972     } catch (...) {
77973       {
77974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
77975       };
77976     }
77977   }
77978
77979   jresult = result;
77980   return jresult;
77981 }
77982
77983
77984 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFitWidth(void * jarg1, unsigned int jarg2) {
77985   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
77986   unsigned int arg2 ;
77987
77988   arg1 = (Dali::Toolkit::TableView *)jarg1;
77989   arg2 = (unsigned int)jarg2;
77990   {
77991     try {
77992       (arg1)->SetFitWidth(arg2);
77993     } catch (std::out_of_range& e) {
77994       {
77995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
77996       };
77997     } catch (std::exception& e) {
77998       {
77999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78000       };
78001     } catch (Dali::DaliException e) {
78002       {
78003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78004       };
78005     } catch (...) {
78006       {
78007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78008       };
78009     }
78010   }
78011
78012 }
78013
78014
78015 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_IsFitWidth(void * jarg1, unsigned int jarg2) {
78016   unsigned int jresult ;
78017   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78018   unsigned int arg2 ;
78019   bool result;
78020
78021   arg1 = (Dali::Toolkit::TableView *)jarg1;
78022   arg2 = (unsigned int)jarg2;
78023   {
78024     try {
78025       result = (bool)((Dali::Toolkit::TableView const *)arg1)->IsFitWidth(arg2);
78026     } catch (std::out_of_range& e) {
78027       {
78028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78029       };
78030     } catch (std::exception& e) {
78031       {
78032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78033       };
78034     } catch (Dali::DaliException e) {
78035       {
78036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78037       };
78038     } catch (...) {
78039       {
78040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78041       };
78042     }
78043   }
78044
78045   jresult = result;
78046   return jresult;
78047 }
78048
78049
78050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78051   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78052   unsigned int arg2 ;
78053   float arg3 ;
78054
78055   arg1 = (Dali::Toolkit::TableView *)jarg1;
78056   arg2 = (unsigned int)jarg2;
78057   arg3 = (float)jarg3;
78058   {
78059     try {
78060       (arg1)->SetFixedHeight(arg2,arg3);
78061     } catch (std::out_of_range& e) {
78062       {
78063         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78064       };
78065     } catch (std::exception& e) {
78066       {
78067         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78068       };
78069     } catch (Dali::DaliException e) {
78070       {
78071         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78072       };
78073     } catch (...) {
78074       {
78075         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78076       };
78077     }
78078   }
78079
78080 }
78081
78082
78083 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedHeight(void * jarg1, unsigned int jarg2) {
78084   float jresult ;
78085   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78086   unsigned int arg2 ;
78087   float result;
78088
78089   arg1 = (Dali::Toolkit::TableView *)jarg1;
78090   arg2 = (unsigned int)jarg2;
78091   {
78092     try {
78093       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedHeight(arg2);
78094     } catch (std::out_of_range& e) {
78095       {
78096         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78097       };
78098     } catch (std::exception& e) {
78099       {
78100         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78101       };
78102     } catch (Dali::DaliException e) {
78103       {
78104         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78105       };
78106     } catch (...) {
78107       {
78108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78109       };
78110     }
78111   }
78112
78113   jresult = result;
78114   return jresult;
78115 }
78116
78117
78118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeHeight(void * jarg1, unsigned int jarg2, float jarg3) {
78119   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78120   unsigned int arg2 ;
78121   float arg3 ;
78122
78123   arg1 = (Dali::Toolkit::TableView *)jarg1;
78124   arg2 = (unsigned int)jarg2;
78125   arg3 = (float)jarg3;
78126   {
78127     try {
78128       (arg1)->SetRelativeHeight(arg2,arg3);
78129     } catch (std::out_of_range& e) {
78130       {
78131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78132       };
78133     } catch (std::exception& e) {
78134       {
78135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78136       };
78137     } catch (Dali::DaliException e) {
78138       {
78139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78140       };
78141     } catch (...) {
78142       {
78143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78144       };
78145     }
78146   }
78147
78148 }
78149
78150
78151 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeHeight(void * jarg1, unsigned int jarg2) {
78152   float jresult ;
78153   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78154   unsigned int arg2 ;
78155   float result;
78156
78157   arg1 = (Dali::Toolkit::TableView *)jarg1;
78158   arg2 = (unsigned int)jarg2;
78159   {
78160     try {
78161       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeHeight(arg2);
78162     } catch (std::out_of_range& e) {
78163       {
78164         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78165       };
78166     } catch (std::exception& e) {
78167       {
78168         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78169       };
78170     } catch (Dali::DaliException e) {
78171       {
78172         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78173       };
78174     } catch (...) {
78175       {
78176         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78177       };
78178     }
78179   }
78180
78181   jresult = result;
78182   return jresult;
78183 }
78184
78185
78186 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetFixedWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78187   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78188   unsigned int arg2 ;
78189   float arg3 ;
78190
78191   arg1 = (Dali::Toolkit::TableView *)jarg1;
78192   arg2 = (unsigned int)jarg2;
78193   arg3 = (float)jarg3;
78194   {
78195     try {
78196       (arg1)->SetFixedWidth(arg2,arg3);
78197     } catch (std::out_of_range& e) {
78198       {
78199         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78200       };
78201     } catch (std::exception& e) {
78202       {
78203         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78204       };
78205     } catch (Dali::DaliException e) {
78206       {
78207         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78208       };
78209     } catch (...) {
78210       {
78211         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78212       };
78213     }
78214   }
78215
78216 }
78217
78218
78219 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetFixedWidth(void * jarg1, unsigned int jarg2) {
78220   float jresult ;
78221   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78222   unsigned int arg2 ;
78223   float result;
78224
78225   arg1 = (Dali::Toolkit::TableView *)jarg1;
78226   arg2 = (unsigned int)jarg2;
78227   {
78228     try {
78229       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetFixedWidth(arg2);
78230     } catch (std::out_of_range& e) {
78231       {
78232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78233       };
78234     } catch (std::exception& e) {
78235       {
78236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78237       };
78238     } catch (Dali::DaliException e) {
78239       {
78240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78241       };
78242     } catch (...) {
78243       {
78244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78245       };
78246     }
78247   }
78248
78249   jresult = result;
78250   return jresult;
78251 }
78252
78253
78254 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetRelativeWidth(void * jarg1, unsigned int jarg2, float jarg3) {
78255   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78256   unsigned int arg2 ;
78257   float arg3 ;
78258
78259   arg1 = (Dali::Toolkit::TableView *)jarg1;
78260   arg2 = (unsigned int)jarg2;
78261   arg3 = (float)jarg3;
78262   {
78263     try {
78264       (arg1)->SetRelativeWidth(arg2,arg3);
78265     } catch (std::out_of_range& e) {
78266       {
78267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78268       };
78269     } catch (std::exception& e) {
78270       {
78271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78272       };
78273     } catch (Dali::DaliException e) {
78274       {
78275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78276       };
78277     } catch (...) {
78278       {
78279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78280       };
78281     }
78282   }
78283
78284 }
78285
78286
78287 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_TableView_GetRelativeWidth(void * jarg1, unsigned int jarg2) {
78288   float jresult ;
78289   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78290   unsigned int arg2 ;
78291   float result;
78292
78293   arg1 = (Dali::Toolkit::TableView *)jarg1;
78294   arg2 = (unsigned int)jarg2;
78295   {
78296     try {
78297       result = (float)((Dali::Toolkit::TableView const *)arg1)->GetRelativeWidth(arg2);
78298     } catch (std::out_of_range& e) {
78299       {
78300         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78301       };
78302     } catch (std::exception& e) {
78303       {
78304         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78305       };
78306     } catch (Dali::DaliException e) {
78307       {
78308         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78309       };
78310     } catch (...) {
78311       {
78312         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78313       };
78314     }
78315   }
78316
78317   jresult = result;
78318   return jresult;
78319 }
78320
78321
78322 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetRows(void * jarg1) {
78323   unsigned int jresult ;
78324   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78325   unsigned int result;
78326
78327   arg1 = (Dali::Toolkit::TableView *)jarg1;
78328   {
78329     try {
78330       result = (unsigned int)(arg1)->GetRows();
78331     } catch (std::out_of_range& e) {
78332       {
78333         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78334       };
78335     } catch (std::exception& e) {
78336       {
78337         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78338       };
78339     } catch (Dali::DaliException e) {
78340       {
78341         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78342       };
78343     } catch (...) {
78344       {
78345         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78346       };
78347     }
78348   }
78349
78350   jresult = result;
78351   return jresult;
78352 }
78353
78354
78355 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_TableView_GetColumns(void * jarg1) {
78356   unsigned int jresult ;
78357   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78358   unsigned int result;
78359
78360   arg1 = (Dali::Toolkit::TableView *)jarg1;
78361   {
78362     try {
78363       result = (unsigned int)(arg1)->GetColumns();
78364     } catch (std::out_of_range& e) {
78365       {
78366         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78367       };
78368     } catch (std::exception& e) {
78369       {
78370         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78371       };
78372     } catch (Dali::DaliException e) {
78373       {
78374         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78375       };
78376     } catch (...) {
78377       {
78378         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78379       };
78380     }
78381   }
78382
78383   jresult = result;
78384   return jresult;
78385 }
78386
78387
78388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_TableView_SetCellAlignment(void * jarg1, void * jarg2, int jarg3, int jarg4) {
78389   Dali::Toolkit::TableView *arg1 = (Dali::Toolkit::TableView *) 0 ;
78390   Dali::Toolkit::TableView::CellPosition arg2 ;
78391   Dali::HorizontalAlignment::Type arg3 ;
78392   Dali::VerticalAlignment::Type arg4 ;
78393   Dali::Toolkit::TableView::CellPosition *argp2 ;
78394
78395   arg1 = (Dali::Toolkit::TableView *)jarg1;
78396   argp2 = (Dali::Toolkit::TableView::CellPosition *)jarg2;
78397   if (!argp2) {
78398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::TableView::CellPosition", 0);
78399     return ;
78400   }
78401   arg2 = *argp2;
78402   arg3 = (Dali::HorizontalAlignment::Type)jarg3;
78403   arg4 = (Dali::VerticalAlignment::Type)jarg4;
78404   {
78405     try {
78406       (arg1)->SetCellAlignment(arg2,arg3,arg4);
78407     } catch (std::out_of_range& e) {
78408       {
78409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78410       };
78411     } catch (std::exception& e) {
78412       {
78413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78414       };
78415     } catch (Dali::DaliException e) {
78416       {
78417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78418       };
78419     } catch (...) {
78420       {
78421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78422       };
78423     }
78424   }
78425
78426 }
78427
78428
78429 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_DEFAULT_RENDERING_BACKEND_get() {
78430   unsigned int jresult ;
78431   unsigned int result;
78432
78433   result = (unsigned int)(unsigned int)Dali::Toolkit::DevelText::DEFAULT_RENDERING_BACKEND;
78434   jresult = result;
78435   return jresult;
78436 }
78437
78438
78439 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_get() {
78440   int jresult ;
78441   int result;
78442
78443   result = (int)Dali::Toolkit::TextLabel::Property::TEXT;
78444   jresult = (int)result;
78445   return jresult;
78446 }
78447
78448
78449 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_FAMILY_get() {
78450   int jresult ;
78451   int result;
78452
78453   result = (int)Dali::Toolkit::TextLabel::Property::FONT_FAMILY;
78454   jresult = (int)result;
78455   return jresult;
78456 }
78457
78458
78459 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_FONT_STYLE_get() {
78460   int jresult ;
78461   int result;
78462
78463   result = (int)Dali::Toolkit::TextLabel::Property::FONT_STYLE;
78464   jresult = (int)result;
78465   return jresult;
78466 }
78467
78468
78469 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_POINT_SIZE_get() {
78470   int jresult ;
78471   int result;
78472
78473   result = (int)Dali::Toolkit::TextLabel::Property::POINT_SIZE;
78474   jresult = (int)result;
78475   return jresult;
78476 }
78477
78478
78479 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_MULTI_LINE_get() {
78480   int jresult ;
78481   int result;
78482
78483   result = (int)Dali::Toolkit::TextLabel::Property::MULTI_LINE;
78484   jresult = (int)result;
78485   return jresult;
78486 }
78487
78488
78489 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_HORIZONTAL_ALIGNMENT_get() {
78490   int jresult ;
78491   int result;
78492
78493   result = (int)Dali::Toolkit::TextLabel::Property::HORIZONTAL_ALIGNMENT;
78494   jresult = (int)result;
78495   return jresult;
78496 }
78497
78498
78499 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_VERTICAL_ALIGNMENT_get() {
78500   int jresult ;
78501   int result;
78502
78503   result = (int)Dali::Toolkit::TextLabel::Property::VERTICAL_ALIGNMENT;
78504   jresult = (int)result;
78505   return jresult;
78506 }
78507
78508
78509 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_TEXT_COLOR_get() {
78510   int jresult ;
78511   int result;
78512
78513   result = (int)Dali::Toolkit::TextLabel::Property::TEXT_COLOR;
78514   jresult = (int)result;
78515   return jresult;
78516 }
78517
78518
78519 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_MARKUP_get() {
78520   int jresult ;
78521   int result;
78522
78523   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_MARKUP;
78524   jresult = (int)result;
78525   return jresult;
78526 }
78527
78528
78529 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_ENABLE_AUTO_SCROLL_get() {
78530   int jresult ;
78531   int result;
78532
78533   result = (int)Dali::Toolkit::TextLabel::Property::ENABLE_AUTO_SCROLL;
78534   jresult = (int)result;
78535   return jresult;
78536 }
78537
78538
78539 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_SPEED_get() {
78540   int jresult ;
78541   int result;
78542
78543   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_SPEED;
78544   jresult = (int)result;
78545   return jresult;
78546 }
78547
78548
78549 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_LOOP_COUNT_get() {
78550   int jresult ;
78551   int result;
78552
78553   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_LOOP_COUNT;
78554   jresult = (int)result;
78555   return jresult;
78556 }
78557
78558
78559 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_AUTO_SCROLL_GAP_get() {
78560   int jresult ;
78561   int result;
78562
78563   result = (int)Dali::Toolkit::TextLabel::Property::AUTO_SCROLL_GAP;
78564   jresult = (int)result;
78565   return jresult;
78566 }
78567
78568
78569 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_LINE_SPACING_get() {
78570   int jresult ;
78571   int result;
78572
78573   result = (int)Dali::Toolkit::TextLabel::Property::LINE_SPACING;
78574   jresult = (int)result;
78575   return jresult;
78576 }
78577
78578
78579 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_UNDERLINE_get() {
78580   int jresult ;
78581   int result;
78582
78583   result = (int)Dali::Toolkit::TextLabel::Property::UNDERLINE;
78584   jresult = (int)result;
78585   return jresult;
78586 }
78587
78588
78589 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_SHADOW_get() {
78590   int jresult ;
78591   int result;
78592
78593   result = (int)Dali::Toolkit::TextLabel::Property::SHADOW;
78594   jresult = (int)result;
78595   return jresult;
78596 }
78597
78598
78599 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_EMBOSS_get() {
78600   int jresult ;
78601   int result;
78602
78603   result = (int)Dali::Toolkit::TextLabel::Property::EMBOSS;
78604   jresult = (int)result;
78605   return jresult;
78606 }
78607
78608
78609 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_TextLabel_Property_OUTLINE_get() {
78610   int jresult ;
78611   int result;
78612
78613   result = (int)Dali::Toolkit::TextLabel::Property::OUTLINE;
78614   jresult = (int)result;
78615   return jresult;
78616 }
78617
78618
78619 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel_Property() {
78620   void * jresult ;
78621   Dali::Toolkit::TextLabel::Property *result = 0 ;
78622
78623   {
78624     try {
78625       result = (Dali::Toolkit::TextLabel::Property *)new Dali::Toolkit::TextLabel::Property();
78626     } catch (std::out_of_range& e) {
78627       {
78628         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78629       };
78630     } catch (std::exception& e) {
78631       {
78632         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78633       };
78634     } catch (Dali::DaliException e) {
78635       {
78636         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78637       };
78638     } catch (...) {
78639       {
78640         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78641       };
78642     }
78643   }
78644
78645   jresult = (void *)result;
78646   return jresult;
78647 }
78648
78649
78650 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel_Property(void * jarg1) {
78651   Dali::Toolkit::TextLabel::Property *arg1 = (Dali::Toolkit::TextLabel::Property *) 0 ;
78652
78653   arg1 = (Dali::Toolkit::TextLabel::Property *)jarg1;
78654   {
78655     try {
78656       delete arg1;
78657     } catch (std::out_of_range& e) {
78658       {
78659         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78660       };
78661     } catch (std::exception& e) {
78662       {
78663         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78664       };
78665     } catch (Dali::DaliException e) {
78666       {
78667         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78668       };
78669     } catch (...) {
78670       {
78671         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78672       };
78673     }
78674   }
78675
78676 }
78677
78678
78679 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_0() {
78680   void * jresult ;
78681   Dali::Toolkit::TextLabel result;
78682
78683   {
78684     try {
78685       result = Dali::Toolkit::TextLabel::New();
78686     } catch (std::out_of_range& e) {
78687       {
78688         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78689       };
78690     } catch (std::exception& e) {
78691       {
78692         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78693       };
78694     } catch (Dali::DaliException e) {
78695       {
78696         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78697       };
78698     } catch (...) {
78699       {
78700         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78701       };
78702     }
78703   }
78704
78705   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78706   return jresult;
78707 }
78708
78709
78710 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_New__SWIG_1(char * jarg1) {
78711   void * jresult ;
78712   std::string *arg1 = 0 ;
78713   Dali::Toolkit::TextLabel result;
78714
78715   if (!jarg1) {
78716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
78717     return 0;
78718   }
78719   std::string arg1_str(jarg1);
78720   arg1 = &arg1_str;
78721   {
78722     try {
78723       result = Dali::Toolkit::TextLabel::New((std::string const &)*arg1);
78724     } catch (std::out_of_range& e) {
78725       {
78726         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78727       };
78728     } catch (std::exception& e) {
78729       {
78730         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78731       };
78732     } catch (Dali::DaliException e) {
78733       {
78734         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78735       };
78736     } catch (...) {
78737       {
78738         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78739       };
78740     }
78741   }
78742
78743   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78744
78745   //argout typemap for const std::string&
78746
78747   return jresult;
78748 }
78749
78750
78751 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_0() {
78752   void * jresult ;
78753   Dali::Toolkit::TextLabel *result = 0 ;
78754
78755   {
78756     try {
78757       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel();
78758     } catch (std::out_of_range& e) {
78759       {
78760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78761       };
78762     } catch (std::exception& e) {
78763       {
78764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78765       };
78766     } catch (Dali::DaliException e) {
78767       {
78768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78769       };
78770     } catch (...) {
78771       {
78772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78773       };
78774     }
78775   }
78776
78777   jresult = (void *)result;
78778   return jresult;
78779 }
78780
78781
78782 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_TextLabel__SWIG_1(void * jarg1) {
78783   void * jresult ;
78784   Dali::Toolkit::TextLabel *arg1 = 0 ;
78785   Dali::Toolkit::TextLabel *result = 0 ;
78786
78787   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78788   if (!arg1) {
78789     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78790     return 0;
78791   }
78792   {
78793     try {
78794       result = (Dali::Toolkit::TextLabel *)new Dali::Toolkit::TextLabel((Dali::Toolkit::TextLabel const &)*arg1);
78795     } catch (std::out_of_range& e) {
78796       {
78797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78798       };
78799     } catch (std::exception& e) {
78800       {
78801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78802       };
78803     } catch (Dali::DaliException e) {
78804       {
78805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78806       };
78807     } catch (...) {
78808       {
78809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78810       };
78811     }
78812   }
78813
78814   jresult = (void *)result;
78815   return jresult;
78816 }
78817
78818
78819 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_Assign(void * jarg1, void * jarg2) {
78820   void * jresult ;
78821   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78822   Dali::Toolkit::TextLabel *arg2 = 0 ;
78823   Dali::Toolkit::TextLabel *result = 0 ;
78824
78825   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78826   arg2 = (Dali::Toolkit::TextLabel *)jarg2;
78827   if (!arg2) {
78828     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::TextLabel const & type is null", 0);
78829     return 0;
78830   }
78831   {
78832     try {
78833       result = (Dali::Toolkit::TextLabel *) &(arg1)->operator =((Dali::Toolkit::TextLabel const &)*arg2);
78834     } catch (std::out_of_range& e) {
78835       {
78836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78837       };
78838     } catch (std::exception& e) {
78839       {
78840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78841       };
78842     } catch (Dali::DaliException e) {
78843       {
78844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78845       };
78846     } catch (...) {
78847       {
78848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78849       };
78850     }
78851   }
78852
78853   jresult = (void *)result;
78854   return jresult;
78855 }
78856
78857
78858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_TextLabel(void * jarg1) {
78859   Dali::Toolkit::TextLabel *arg1 = (Dali::Toolkit::TextLabel *) 0 ;
78860
78861   arg1 = (Dali::Toolkit::TextLabel *)jarg1;
78862   {
78863     try {
78864       delete arg1;
78865     } catch (std::out_of_range& e) {
78866       {
78867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78868       };
78869     } catch (std::exception& e) {
78870       {
78871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78872       };
78873     } catch (Dali::DaliException e) {
78874       {
78875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78876       };
78877     } catch (...) {
78878       {
78879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78880       };
78881     }
78882   }
78883
78884 }
78885
78886
78887 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_TextLabel_DownCast(void * jarg1) {
78888   void * jresult ;
78889   Dali::BaseHandle arg1 ;
78890   Dali::BaseHandle *argp1 ;
78891   Dali::Toolkit::TextLabel result;
78892
78893   argp1 = (Dali::BaseHandle *)jarg1;
78894   if (!argp1) {
78895     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
78896     return 0;
78897   }
78898   arg1 = *argp1;
78899   {
78900     try {
78901       result = Dali::Toolkit::TextLabel::DownCast(arg1);
78902     } catch (std::out_of_range& e) {
78903       {
78904         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78905       };
78906     } catch (std::exception& e) {
78907       {
78908         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78909       };
78910     } catch (Dali::DaliException e) {
78911       {
78912         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78913       };
78914     } catch (...) {
78915       {
78916         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78917       };
78918     }
78919   }
78920
78921   jresult = new Dali::Toolkit::TextLabel((const Dali::Toolkit::TextLabel &)result);
78922   return jresult;
78923 }
78924
78925
78926 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityManager() {
78927   void * jresult ;
78928   Dali::Toolkit::AccessibilityManager *result = 0 ;
78929
78930   {
78931     try {
78932       result = (Dali::Toolkit::AccessibilityManager *)new Dali::Toolkit::AccessibilityManager();
78933     } catch (std::out_of_range& e) {
78934       {
78935         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78936       };
78937     } catch (std::exception& e) {
78938       {
78939         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
78940       };
78941     } catch (Dali::DaliException e) {
78942       {
78943         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
78944       };
78945     } catch (...) {
78946       {
78947         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
78948       };
78949     }
78950   }
78951
78952   jresult = (void *)result;
78953   return jresult;
78954 }
78955
78956
78957 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityManager(void * jarg1) {
78958   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
78959
78960   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
78961   {
78962     try {
78963       delete arg1;
78964     } catch (std::out_of_range& e) {
78965       {
78966         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
78967       };
78968     } catch (std::exception& e) {
78969       {
78970         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
78971       };
78972     } catch (Dali::DaliException e) {
78973       {
78974         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
78975       };
78976     } catch (...) {
78977       {
78978         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
78979       };
78980     }
78981   }
78982
78983 }
78984
78985
78986 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_Get() {
78987   void * jresult ;
78988   Dali::Toolkit::AccessibilityManager result;
78989
78990   {
78991     try {
78992       result = Dali::Toolkit::AccessibilityManager::Get();
78993     } catch (std::out_of_range& e) {
78994       {
78995         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
78996       };
78997     } catch (std::exception& e) {
78998       {
78999         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79000       };
79001     } catch (Dali::DaliException e) {
79002       {
79003         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79004       };
79005     } catch (...) {
79006       {
79007         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79008       };
79009     }
79010   }
79011
79012   jresult = new Dali::Toolkit::AccessibilityManager((const Dali::Toolkit::AccessibilityManager &)result);
79013   return jresult;
79014 }
79015
79016
79017 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3, char * jarg4) {
79018   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79019   Dali::Actor arg2 ;
79020   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79021   std::string *arg4 = 0 ;
79022   Dali::Actor *argp2 ;
79023
79024   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79025   argp2 = (Dali::Actor *)jarg2;
79026   if (!argp2) {
79027     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79028     return ;
79029   }
79030   arg2 = *argp2;
79031   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79032   if (!jarg4) {
79033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
79034     return ;
79035   }
79036   std::string arg4_str(jarg4);
79037   arg4 = &arg4_str;
79038   {
79039     try {
79040       (arg1)->SetAccessibilityAttribute(arg2,arg3,(std::string const &)*arg4);
79041     } catch (std::out_of_range& e) {
79042       {
79043         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79044       };
79045     } catch (std::exception& e) {
79046       {
79047         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79048       };
79049     } catch (Dali::DaliException e) {
79050       {
79051         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79052       };
79053     } catch (...) {
79054       {
79055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79056       };
79057     }
79058   }
79059
79060
79061   //argout typemap for const std::string&
79062
79063 }
79064
79065
79066 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetAccessibilityAttribute(void * jarg1, void * jarg2, int jarg3) {
79067   char * jresult ;
79068   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79069   Dali::Actor arg2 ;
79070   Dali::Toolkit::AccessibilityManager::AccessibilityAttribute arg3 ;
79071   Dali::Actor *argp2 ;
79072   std::string result;
79073
79074   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79075   argp2 = (Dali::Actor *)jarg2;
79076   if (!argp2) {
79077     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79078     return 0;
79079   }
79080   arg2 = *argp2;
79081   arg3 = (Dali::Toolkit::AccessibilityManager::AccessibilityAttribute)jarg3;
79082   {
79083     try {
79084       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetAccessibilityAttribute(arg2,arg3);
79085     } catch (std::out_of_range& e) {
79086       {
79087         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79088       };
79089     } catch (std::exception& e) {
79090       {
79091         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79092       };
79093     } catch (Dali::DaliException e) {
79094       {
79095         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79096       };
79097     } catch (...) {
79098       {
79099         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79100       };
79101     }
79102   }
79103
79104   jresult = SWIG_csharp_string_callback((&result)->c_str());
79105   return jresult;
79106 }
79107
79108
79109 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusOrder(void * jarg1, void * jarg2, unsigned int jarg3) {
79110   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79111   Dali::Actor arg2 ;
79112   unsigned int arg3 ;
79113   Dali::Actor *argp2 ;
79114
79115   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79116   argp2 = (Dali::Actor *)jarg2;
79117   if (!argp2) {
79118     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79119     return ;
79120   }
79121   arg2 = *argp2;
79122   arg3 = (unsigned int)jarg3;
79123   {
79124     try {
79125       (arg1)->SetFocusOrder(arg2,arg3);
79126     } catch (std::out_of_range& e) {
79127       {
79128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79129       };
79130     } catch (std::exception& e) {
79131       {
79132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79133       };
79134     } catch (Dali::DaliException e) {
79135       {
79136         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79137       };
79138     } catch (...) {
79139       {
79140         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79141       };
79142     }
79143   }
79144
79145 }
79146
79147
79148 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusOrder(void * jarg1, void * jarg2) {
79149   unsigned int jresult ;
79150   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79151   Dali::Actor arg2 ;
79152   Dali::Actor *argp2 ;
79153   unsigned int result;
79154
79155   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79156   argp2 = (Dali::Actor *)jarg2;
79157   if (!argp2) {
79158     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79159     return 0;
79160   }
79161   arg2 = *argp2;
79162   {
79163     try {
79164       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetFocusOrder(arg2);
79165     } catch (std::out_of_range& e) {
79166       {
79167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79168       };
79169     } catch (std::exception& e) {
79170       {
79171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79172       };
79173     } catch (Dali::DaliException e) {
79174       {
79175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79176       };
79177     } catch (...) {
79178       {
79179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79180       };
79181     }
79182   }
79183
79184   jresult = result;
79185   return jresult;
79186 }
79187
79188
79189 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GenerateNewFocusOrder(void * jarg1) {
79190   unsigned int jresult ;
79191   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79192   unsigned int result;
79193
79194   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79195   {
79196     try {
79197       result = (unsigned int)((Dali::Toolkit::AccessibilityManager const *)arg1)->GenerateNewFocusOrder();
79198     } catch (std::out_of_range& e) {
79199       {
79200         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79201       };
79202     } catch (std::exception& e) {
79203       {
79204         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79205       };
79206     } catch (Dali::DaliException e) {
79207       {
79208         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79209       };
79210     } catch (...) {
79211       {
79212         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79213       };
79214     }
79215   }
79216
79217   jresult = result;
79218   return jresult;
79219 }
79220
79221
79222 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetActorByFocusOrder(void * jarg1, unsigned int jarg2) {
79223   void * jresult ;
79224   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79225   unsigned int arg2 ;
79226   Dali::Actor result;
79227
79228   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79229   arg2 = (unsigned int)jarg2;
79230   {
79231     try {
79232       result = (arg1)->GetActorByFocusOrder(arg2);
79233     } catch (std::out_of_range& e) {
79234       {
79235         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79236       };
79237     } catch (std::exception& e) {
79238       {
79239         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79240       };
79241     } catch (Dali::DaliException e) {
79242       {
79243         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79244       };
79245     } catch (...) {
79246       {
79247         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79248       };
79249     }
79250   }
79251
79252   jresult = new Dali::Actor((const Dali::Actor &)result);
79253   return jresult;
79254 }
79255
79256
79257 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetCurrentFocusActor(void * jarg1, void * jarg2) {
79258   unsigned int jresult ;
79259   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79260   Dali::Actor arg2 ;
79261   Dali::Actor *argp2 ;
79262   bool result;
79263
79264   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79265   argp2 = (Dali::Actor *)jarg2;
79266   if (!argp2) {
79267     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79268     return 0;
79269   }
79270   arg2 = *argp2;
79271   {
79272     try {
79273       result = (bool)(arg1)->SetCurrentFocusActor(arg2);
79274     } catch (std::out_of_range& e) {
79275       {
79276         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79277       };
79278     } catch (std::exception& e) {
79279       {
79280         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79281       };
79282     } catch (Dali::DaliException e) {
79283       {
79284         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79285       };
79286     } catch (...) {
79287       {
79288         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79289       };
79290     }
79291   }
79292
79293   jresult = result;
79294   return jresult;
79295 }
79296
79297
79298 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusActor(void * jarg1) {
79299   void * jresult ;
79300   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79301   Dali::Actor result;
79302
79303   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79304   {
79305     try {
79306       result = (arg1)->GetCurrentFocusActor();
79307     } catch (std::out_of_range& e) {
79308       {
79309         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79310       };
79311     } catch (std::exception& e) {
79312       {
79313         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79314       };
79315     } catch (Dali::DaliException e) {
79316       {
79317         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79318       };
79319     } catch (...) {
79320       {
79321         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79322       };
79323     }
79324   }
79325
79326   jresult = new Dali::Actor((const Dali::Actor &)result);
79327   return jresult;
79328 }
79329
79330
79331 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusGroup(void * jarg1) {
79332   void * jresult ;
79333   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79334   Dali::Actor result;
79335
79336   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79337   {
79338     try {
79339       result = (arg1)->GetCurrentFocusGroup();
79340     } catch (std::out_of_range& e) {
79341       {
79342         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79343       };
79344     } catch (std::exception& e) {
79345       {
79346         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79347       };
79348     } catch (Dali::DaliException e) {
79349       {
79350         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79351       };
79352     } catch (...) {
79353       {
79354         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79355       };
79356     }
79357   }
79358
79359   jresult = new Dali::Actor((const Dali::Actor &)result);
79360   return jresult;
79361 }
79362
79363
79364 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetCurrentFocusOrder(void * jarg1) {
79365   unsigned int jresult ;
79366   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79367   unsigned int result;
79368
79369   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79370   {
79371     try {
79372       result = (unsigned int)(arg1)->GetCurrentFocusOrder();
79373     } catch (std::out_of_range& e) {
79374       {
79375         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79376       };
79377     } catch (std::exception& e) {
79378       {
79379         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79380       };
79381     } catch (Dali::DaliException e) {
79382       {
79383         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79384       };
79385     } catch (...) {
79386       {
79387         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79388       };
79389     }
79390   }
79391
79392   jresult = result;
79393   return jresult;
79394 }
79395
79396
79397 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusForward(void * jarg1) {
79398   unsigned int jresult ;
79399   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79400   bool result;
79401
79402   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79403   {
79404     try {
79405       result = (bool)(arg1)->MoveFocusForward();
79406     } catch (std::out_of_range& e) {
79407       {
79408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79409       };
79410     } catch (std::exception& e) {
79411       {
79412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79413       };
79414     } catch (Dali::DaliException e) {
79415       {
79416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79417       };
79418     } catch (...) {
79419       {
79420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79421       };
79422     }
79423   }
79424
79425   jresult = result;
79426   return jresult;
79427 }
79428
79429
79430 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_MoveFocusBackward(void * jarg1) {
79431   unsigned int jresult ;
79432   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79433   bool result;
79434
79435   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79436   {
79437     try {
79438       result = (bool)(arg1)->MoveFocusBackward();
79439     } catch (std::out_of_range& e) {
79440       {
79441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79442       };
79443     } catch (std::exception& e) {
79444       {
79445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79446       };
79447     } catch (Dali::DaliException e) {
79448       {
79449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79450       };
79451     } catch (...) {
79452       {
79453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79454       };
79455     }
79456   }
79457
79458   jresult = result;
79459   return jresult;
79460 }
79461
79462
79463 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_ClearFocus(void * jarg1) {
79464   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79465
79466   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79467   {
79468     try {
79469       (arg1)->ClearFocus();
79470     } catch (std::out_of_range& e) {
79471       {
79472         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79473       };
79474     } catch (std::exception& e) {
79475       {
79476         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79477       };
79478     } catch (Dali::DaliException e) {
79479       {
79480         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79481       };
79482     } catch (...) {
79483       {
79484         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79485       };
79486     }
79487   }
79488
79489 }
79490
79491
79492 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_Reset(void * jarg1) {
79493   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79494
79495   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79496   {
79497     try {
79498       (arg1)->Reset();
79499     } catch (std::out_of_range& e) {
79500       {
79501         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79502       };
79503     } catch (std::exception& e) {
79504       {
79505         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79506       };
79507     } catch (Dali::DaliException e) {
79508       {
79509         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79510       };
79511     } catch (...) {
79512       {
79513         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79514       };
79515     }
79516   }
79517
79518 }
79519
79520
79521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusGroup(void * jarg1, void * jarg2, unsigned int jarg3) {
79522   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79523   Dali::Actor arg2 ;
79524   bool arg3 ;
79525   Dali::Actor *argp2 ;
79526
79527   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79528   argp2 = (Dali::Actor *)jarg2;
79529   if (!argp2) {
79530     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79531     return ;
79532   }
79533   arg2 = *argp2;
79534   arg3 = jarg3 ? true : false;
79535   {
79536     try {
79537       (arg1)->SetFocusGroup(arg2,arg3);
79538     } catch (std::out_of_range& e) {
79539       {
79540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79541       };
79542     } catch (std::exception& e) {
79543       {
79544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79545       };
79546     } catch (Dali::DaliException e) {
79547       {
79548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79549       };
79550     } catch (...) {
79551       {
79552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79553       };
79554     }
79555   }
79556
79557 }
79558
79559
79560 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_IsFocusGroup(void * jarg1, void * jarg2) {
79561   unsigned int jresult ;
79562   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79563   Dali::Actor arg2 ;
79564   Dali::Actor *argp2 ;
79565   bool result;
79566
79567   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79568   argp2 = (Dali::Actor *)jarg2;
79569   if (!argp2) {
79570     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79571     return 0;
79572   }
79573   arg2 = *argp2;
79574   {
79575     try {
79576       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->IsFocusGroup(arg2);
79577     } catch (std::out_of_range& e) {
79578       {
79579         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79580       };
79581     } catch (std::exception& e) {
79582       {
79583         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79584       };
79585     } catch (Dali::DaliException e) {
79586       {
79587         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79588       };
79589     } catch (...) {
79590       {
79591         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79592       };
79593     }
79594   }
79595
79596   jresult = result;
79597   return jresult;
79598 }
79599
79600
79601 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetGroupMode(void * jarg1, unsigned int jarg2) {
79602   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79603   bool arg2 ;
79604
79605   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79606   arg2 = jarg2 ? true : false;
79607   {
79608     try {
79609       (arg1)->SetGroupMode(arg2);
79610     } catch (std::out_of_range& e) {
79611       {
79612         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79613       };
79614     } catch (std::exception& e) {
79615       {
79616         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79617       };
79618     } catch (Dali::DaliException e) {
79619       {
79620         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79621       };
79622     } catch (...) {
79623       {
79624         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79625       };
79626     }
79627   }
79628
79629 }
79630
79631
79632 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetGroupMode(void * jarg1) {
79633   unsigned int jresult ;
79634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79635   bool result;
79636
79637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79638   {
79639     try {
79640       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetGroupMode();
79641     } catch (std::out_of_range& e) {
79642       {
79643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79644       };
79645     } catch (std::exception& e) {
79646       {
79647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79648       };
79649     } catch (Dali::DaliException e) {
79650       {
79651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79652       };
79653     } catch (...) {
79654       {
79655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79656       };
79657     }
79658   }
79659
79660   jresult = result;
79661   return jresult;
79662 }
79663
79664
79665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetWrapMode(void * jarg1, unsigned int jarg2) {
79666   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79667   bool arg2 ;
79668
79669   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79670   arg2 = jarg2 ? true : false;
79671   {
79672     try {
79673       (arg1)->SetWrapMode(arg2);
79674     } catch (std::out_of_range& e) {
79675       {
79676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79677       };
79678     } catch (std::exception& e) {
79679       {
79680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79681       };
79682     } catch (Dali::DaliException e) {
79683       {
79684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79685       };
79686     } catch (...) {
79687       {
79688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79689       };
79690     }
79691   }
79692
79693 }
79694
79695
79696 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetWrapMode(void * jarg1) {
79697   unsigned int jresult ;
79698   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79699   bool result;
79700
79701   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79702   {
79703     try {
79704       result = (bool)((Dali::Toolkit::AccessibilityManager const *)arg1)->GetWrapMode();
79705     } catch (std::out_of_range& e) {
79706       {
79707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79708       };
79709     } catch (std::exception& e) {
79710       {
79711         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79712       };
79713     } catch (Dali::DaliException e) {
79714       {
79715         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79716       };
79717     } catch (...) {
79718       {
79719         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79720       };
79721     }
79722   }
79723
79724   jresult = result;
79725   return jresult;
79726 }
79727
79728
79729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityManager_SetFocusIndicatorActor(void * jarg1, void * jarg2) {
79730   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79731   Dali::Actor arg2 ;
79732   Dali::Actor *argp2 ;
79733
79734   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79735   argp2 = (Dali::Actor *)jarg2;
79736   if (!argp2) {
79737     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79738     return ;
79739   }
79740   arg2 = *argp2;
79741   {
79742     try {
79743       (arg1)->SetFocusIndicatorActor(arg2);
79744     } catch (std::out_of_range& e) {
79745       {
79746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
79747       };
79748     } catch (std::exception& e) {
79749       {
79750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
79751       };
79752     } catch (Dali::DaliException e) {
79753       {
79754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
79755       };
79756     } catch (...) {
79757       {
79758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
79759       };
79760     }
79761   }
79762
79763 }
79764
79765
79766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusIndicatorActor(void * jarg1) {
79767   void * jresult ;
79768   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79769   Dali::Actor result;
79770
79771   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79772   {
79773     try {
79774       result = (arg1)->GetFocusIndicatorActor();
79775     } catch (std::out_of_range& e) {
79776       {
79777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79778       };
79779     } catch (std::exception& e) {
79780       {
79781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79782       };
79783     } catch (Dali::DaliException e) {
79784       {
79785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79786       };
79787     } catch (...) {
79788       {
79789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79790       };
79791     }
79792   }
79793
79794   jresult = new Dali::Actor((const Dali::Actor &)result);
79795   return jresult;
79796 }
79797
79798
79799 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetFocusGroup(void * jarg1, void * jarg2) {
79800   void * jresult ;
79801   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79802   Dali::Actor arg2 ;
79803   Dali::Actor *argp2 ;
79804   Dali::Actor result;
79805
79806   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79807   argp2 = (Dali::Actor *)jarg2;
79808   if (!argp2) {
79809     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
79810     return 0;
79811   }
79812   arg2 = *argp2;
79813   {
79814     try {
79815       result = (arg1)->GetFocusGroup(arg2);
79816     } catch (std::out_of_range& e) {
79817       {
79818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79819       };
79820     } catch (std::exception& e) {
79821       {
79822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79823       };
79824     } catch (Dali::DaliException e) {
79825       {
79826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79827       };
79828     } catch (...) {
79829       {
79830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79831       };
79832     }
79833   }
79834
79835   jresult = new Dali::Actor((const Dali::Actor &)result);
79836   return jresult;
79837 }
79838
79839
79840 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_GetReadPosition(void * jarg1) {
79841   void * jresult ;
79842   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79843   Dali::Vector2 result;
79844
79845   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79846   {
79847     try {
79848       result = ((Dali::Toolkit::AccessibilityManager const *)arg1)->GetReadPosition();
79849     } catch (std::out_of_range& e) {
79850       {
79851         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79852       };
79853     } catch (std::exception& e) {
79854       {
79855         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79856       };
79857     } catch (Dali::DaliException e) {
79858       {
79859         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79860       };
79861     } catch (...) {
79862       {
79863         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79864       };
79865     }
79866   }
79867
79868   jresult = new Dali::Vector2((const Dali::Vector2 &)result);
79869   return jresult;
79870 }
79871
79872
79873 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusChangedSignal(void * jarg1) {
79874   void * jresult ;
79875   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79876   Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *result = 0 ;
79877
79878   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79879   {
79880     try {
79881       result = (Dali::Toolkit::AccessibilityManager::FocusChangedSignalType *) &(arg1)->FocusChangedSignal();
79882     } catch (std::out_of_range& e) {
79883       {
79884         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79885       };
79886     } catch (std::exception& e) {
79887       {
79888         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79889       };
79890     } catch (Dali::DaliException e) {
79891       {
79892         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79893       };
79894     } catch (...) {
79895       {
79896         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79897       };
79898     }
79899   }
79900
79901   jresult = (void *)result;
79902   return jresult;
79903 }
79904
79905
79906 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusOvershotSignal(void * jarg1) {
79907   void * jresult ;
79908   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79909   Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *result = 0 ;
79910
79911   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79912   {
79913     try {
79914       result = (Dali::Toolkit::AccessibilityManager::FocusOvershotSignalType *) &(arg1)->FocusOvershotSignal();
79915     } catch (std::out_of_range& e) {
79916       {
79917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79918       };
79919     } catch (std::exception& e) {
79920       {
79921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79922       };
79923     } catch (Dali::DaliException e) {
79924       {
79925         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79926       };
79927     } catch (...) {
79928       {
79929         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79930       };
79931     }
79932   }
79933
79934   jresult = (void *)result;
79935   return jresult;
79936 }
79937
79938
79939 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_FocusedActorActivatedSignal(void * jarg1) {
79940   void * jresult ;
79941   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79942   Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *result = 0 ;
79943
79944   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79945   {
79946     try {
79947       result = (Dali::Toolkit::AccessibilityManager::FocusedActorActivatedSignalType *) &(arg1)->FocusedActorActivatedSignal();
79948     } catch (std::out_of_range& e) {
79949       {
79950         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79951       };
79952     } catch (std::exception& e) {
79953       {
79954         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79955       };
79956     } catch (Dali::DaliException e) {
79957       {
79958         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79959       };
79960     } catch (...) {
79961       {
79962         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79963       };
79964     }
79965   }
79966
79967   jresult = (void *)result;
79968   return jresult;
79969 }
79970
79971
79972 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_StatusChangedSignal(void * jarg1) {
79973   void * jresult ;
79974   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
79975   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
79976
79977   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
79978   {
79979     try {
79980       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->StatusChangedSignal();
79981     } catch (std::out_of_range& e) {
79982       {
79983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
79984       };
79985     } catch (std::exception& e) {
79986       {
79987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
79988       };
79989     } catch (Dali::DaliException e) {
79990       {
79991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
79992       };
79993     } catch (...) {
79994       {
79995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
79996       };
79997     }
79998   }
79999
80000   jresult = (void *)result;
80001   return jresult;
80002 }
80003
80004
80005 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionNextSignal(void * jarg1) {
80006   void * jresult ;
80007   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80008   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80009
80010   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80011   {
80012     try {
80013       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionNextSignal();
80014     } catch (std::out_of_range& e) {
80015       {
80016         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80017       };
80018     } catch (std::exception& e) {
80019       {
80020         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80021       };
80022     } catch (Dali::DaliException e) {
80023       {
80024         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80025       };
80026     } catch (...) {
80027       {
80028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80029       };
80030     }
80031   }
80032
80033   jresult = (void *)result;
80034   return jresult;
80035 }
80036
80037
80038 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPreviousSignal(void * jarg1) {
80039   void * jresult ;
80040   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80041   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80042
80043   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80044   {
80045     try {
80046       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPreviousSignal();
80047     } catch (std::out_of_range& e) {
80048       {
80049         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80050       };
80051     } catch (std::exception& e) {
80052       {
80053         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80054       };
80055     } catch (Dali::DaliException e) {
80056       {
80057         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80058       };
80059     } catch (...) {
80060       {
80061         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80062       };
80063     }
80064   }
80065
80066   jresult = (void *)result;
80067   return jresult;
80068 }
80069
80070
80071 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionActivateSignal(void * jarg1) {
80072   void * jresult ;
80073   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80074   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80075
80076   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80077   {
80078     try {
80079       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionActivateSignal();
80080     } catch (std::out_of_range& e) {
80081       {
80082         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80083       };
80084     } catch (std::exception& e) {
80085       {
80086         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80087       };
80088     } catch (Dali::DaliException e) {
80089       {
80090         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80091       };
80092     } catch (...) {
80093       {
80094         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80095       };
80096     }
80097   }
80098
80099   jresult = (void *)result;
80100   return jresult;
80101 }
80102
80103
80104 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadSignal(void * jarg1) {
80105   void * jresult ;
80106   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80107   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80108
80109   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80110   {
80111     try {
80112       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadSignal();
80113     } catch (std::out_of_range& e) {
80114       {
80115         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80116       };
80117     } catch (std::exception& e) {
80118       {
80119         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80120       };
80121     } catch (Dali::DaliException e) {
80122       {
80123         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80124       };
80125     } catch (...) {
80126       {
80127         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80128       };
80129     }
80130   }
80131
80132   jresult = (void *)result;
80133   return jresult;
80134 }
80135
80136
80137 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionOverSignal(void * jarg1) {
80138   void * jresult ;
80139   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80140   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80141
80142   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80143   {
80144     try {
80145       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionOverSignal();
80146     } catch (std::out_of_range& e) {
80147       {
80148         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80149       };
80150     } catch (std::exception& e) {
80151       {
80152         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80153       };
80154     } catch (Dali::DaliException e) {
80155       {
80156         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80157       };
80158     } catch (...) {
80159       {
80160         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80161       };
80162     }
80163   }
80164
80165   jresult = (void *)result;
80166   return jresult;
80167 }
80168
80169
80170 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadNextSignal(void * jarg1) {
80171   void * jresult ;
80172   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80173   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80174
80175   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80176   {
80177     try {
80178       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadNextSignal();
80179     } catch (std::out_of_range& e) {
80180       {
80181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80182       };
80183     } catch (std::exception& e) {
80184       {
80185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80186       };
80187     } catch (Dali::DaliException e) {
80188       {
80189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80190       };
80191     } catch (...) {
80192       {
80193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80194       };
80195     }
80196   }
80197
80198   jresult = (void *)result;
80199   return jresult;
80200 }
80201
80202
80203 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPreviousSignal(void * jarg1) {
80204   void * jresult ;
80205   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80206   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80207
80208   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80209   {
80210     try {
80211       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPreviousSignal();
80212     } catch (std::out_of_range& e) {
80213       {
80214         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80215       };
80216     } catch (std::exception& e) {
80217       {
80218         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80219       };
80220     } catch (Dali::DaliException e) {
80221       {
80222         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80223       };
80224     } catch (...) {
80225       {
80226         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80227       };
80228     }
80229   }
80230
80231   jresult = (void *)result;
80232   return jresult;
80233 }
80234
80235
80236 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionUpSignal(void * jarg1) {
80237   void * jresult ;
80238   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80239   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80240
80241   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80242   {
80243     try {
80244       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionUpSignal();
80245     } catch (std::out_of_range& e) {
80246       {
80247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80248       };
80249     } catch (std::exception& e) {
80250       {
80251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80252       };
80253     } catch (Dali::DaliException e) {
80254       {
80255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80256       };
80257     } catch (...) {
80258       {
80259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80260       };
80261     }
80262   }
80263
80264   jresult = (void *)result;
80265   return jresult;
80266 }
80267
80268
80269 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionDownSignal(void * jarg1) {
80270   void * jresult ;
80271   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80272   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80273
80274   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80275   {
80276     try {
80277       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionDownSignal();
80278     } catch (std::out_of_range& e) {
80279       {
80280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80281       };
80282     } catch (std::exception& e) {
80283       {
80284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80285       };
80286     } catch (Dali::DaliException e) {
80287       {
80288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80289       };
80290     } catch (...) {
80291       {
80292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80293       };
80294     }
80295   }
80296
80297   jresult = (void *)result;
80298   return jresult;
80299 }
80300
80301
80302 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionClearFocusSignal(void * jarg1) {
80303   void * jresult ;
80304   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80305   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80306
80307   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80308   {
80309     try {
80310       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionClearFocusSignal();
80311     } catch (std::out_of_range& e) {
80312       {
80313         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80314       };
80315     } catch (std::exception& e) {
80316       {
80317         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80318       };
80319     } catch (Dali::DaliException e) {
80320       {
80321         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80322       };
80323     } catch (...) {
80324       {
80325         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80326       };
80327     }
80328   }
80329
80330   jresult = (void *)result;
80331   return jresult;
80332 }
80333
80334
80335 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionBackSignal(void * jarg1) {
80336   void * jresult ;
80337   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80338   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80339
80340   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80341   {
80342     try {
80343       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionBackSignal();
80344     } catch (std::out_of_range& e) {
80345       {
80346         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80347       };
80348     } catch (std::exception& e) {
80349       {
80350         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80351       };
80352     } catch (Dali::DaliException e) {
80353       {
80354         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80355       };
80356     } catch (...) {
80357       {
80358         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80359       };
80360     }
80361   }
80362
80363   jresult = (void *)result;
80364   return jresult;
80365 }
80366
80367
80368 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollUpSignal(void * jarg1) {
80369   void * jresult ;
80370   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80371   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80372
80373   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80374   {
80375     try {
80376       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollUpSignal();
80377     } catch (std::out_of_range& e) {
80378       {
80379         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80380       };
80381     } catch (std::exception& e) {
80382       {
80383         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80384       };
80385     } catch (Dali::DaliException e) {
80386       {
80387         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80388       };
80389     } catch (...) {
80390       {
80391         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80392       };
80393     }
80394   }
80395
80396   jresult = (void *)result;
80397   return jresult;
80398 }
80399
80400
80401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollDownSignal(void * jarg1) {
80402   void * jresult ;
80403   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80404   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80405
80406   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80407   {
80408     try {
80409       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionScrollDownSignal();
80410     } catch (std::out_of_range& e) {
80411       {
80412         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80413       };
80414     } catch (std::exception& e) {
80415       {
80416         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80417       };
80418     } catch (Dali::DaliException e) {
80419       {
80420         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80421       };
80422     } catch (...) {
80423       {
80424         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80425       };
80426     }
80427   }
80428
80429   jresult = (void *)result;
80430   return jresult;
80431 }
80432
80433
80434 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageLeftSignal(void * jarg1) {
80435   void * jresult ;
80436   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80437   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80438
80439   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80440   {
80441     try {
80442       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageLeftSignal();
80443     } catch (std::out_of_range& e) {
80444       {
80445         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80446       };
80447     } catch (std::exception& e) {
80448       {
80449         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80450       };
80451     } catch (Dali::DaliException e) {
80452       {
80453         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80454       };
80455     } catch (...) {
80456       {
80457         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80458       };
80459     }
80460   }
80461
80462   jresult = (void *)result;
80463   return jresult;
80464 }
80465
80466
80467 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageRightSignal(void * jarg1) {
80468   void * jresult ;
80469   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80470   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80471
80472   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80473   {
80474     try {
80475       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageRightSignal();
80476     } catch (std::out_of_range& e) {
80477       {
80478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80479       };
80480     } catch (std::exception& e) {
80481       {
80482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80483       };
80484     } catch (Dali::DaliException e) {
80485       {
80486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80487       };
80488     } catch (...) {
80489       {
80490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80491       };
80492     }
80493   }
80494
80495   jresult = (void *)result;
80496   return jresult;
80497 }
80498
80499
80500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageUpSignal(void * jarg1) {
80501   void * jresult ;
80502   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80503   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80504
80505   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80506   {
80507     try {
80508       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageUpSignal();
80509     } catch (std::out_of_range& e) {
80510       {
80511         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80512       };
80513     } catch (std::exception& e) {
80514       {
80515         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80516       };
80517     } catch (Dali::DaliException e) {
80518       {
80519         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80520       };
80521     } catch (...) {
80522       {
80523         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80524       };
80525     }
80526   }
80527
80528   jresult = (void *)result;
80529   return jresult;
80530 }
80531
80532
80533 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionPageDownSignal(void * jarg1) {
80534   void * jresult ;
80535   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80536   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80537
80538   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80539   {
80540     try {
80541       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionPageDownSignal();
80542     } catch (std::out_of_range& e) {
80543       {
80544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80545       };
80546     } catch (std::exception& e) {
80547       {
80548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80549       };
80550     } catch (Dali::DaliException e) {
80551       {
80552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80553       };
80554     } catch (...) {
80555       {
80556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80557       };
80558     }
80559   }
80560
80561   jresult = (void *)result;
80562   return jresult;
80563 }
80564
80565
80566 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToFirstSignal(void * jarg1) {
80567   void * jresult ;
80568   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80569   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80570
80571   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80572   {
80573     try {
80574       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToFirstSignal();
80575     } catch (std::out_of_range& e) {
80576       {
80577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80578       };
80579     } catch (std::exception& e) {
80580       {
80581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80582       };
80583     } catch (Dali::DaliException e) {
80584       {
80585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80586       };
80587     } catch (...) {
80588       {
80589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80590       };
80591     }
80592   }
80593
80594   jresult = (void *)result;
80595   return jresult;
80596 }
80597
80598
80599 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionMoveToLastSignal(void * jarg1) {
80600   void * jresult ;
80601   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80602   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80603
80604   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80605   {
80606     try {
80607       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionMoveToLastSignal();
80608     } catch (std::out_of_range& e) {
80609       {
80610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80611       };
80612     } catch (std::exception& e) {
80613       {
80614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80615       };
80616     } catch (Dali::DaliException e) {
80617       {
80618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80619       };
80620     } catch (...) {
80621       {
80622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80623       };
80624     }
80625   }
80626
80627   jresult = (void *)result;
80628   return jresult;
80629 }
80630
80631
80632 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromTopSignal(void * jarg1) {
80633   void * jresult ;
80634   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80635   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80636
80637   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80638   {
80639     try {
80640       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromTopSignal();
80641     } catch (std::out_of_range& e) {
80642       {
80643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80644       };
80645     } catch (std::exception& e) {
80646       {
80647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80648       };
80649     } catch (Dali::DaliException e) {
80650       {
80651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80652       };
80653     } catch (...) {
80654       {
80655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80656       };
80657     }
80658   }
80659
80660   jresult = (void *)result;
80661   return jresult;
80662 }
80663
80664
80665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadFromNextSignal(void * jarg1) {
80666   void * jresult ;
80667   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80668   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80669
80670   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80671   {
80672     try {
80673       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadFromNextSignal();
80674     } catch (std::out_of_range& e) {
80675       {
80676         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80677       };
80678     } catch (std::exception& e) {
80679       {
80680         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80681       };
80682     } catch (Dali::DaliException e) {
80683       {
80684         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80685       };
80686     } catch (...) {
80687       {
80688         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80689       };
80690     }
80691   }
80692
80693   jresult = (void *)result;
80694   return jresult;
80695 }
80696
80697
80698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionZoomSignal(void * jarg1) {
80699   void * jresult ;
80700   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80701   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80702
80703   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80704   {
80705     try {
80706       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionZoomSignal();
80707     } catch (std::out_of_range& e) {
80708       {
80709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80710       };
80711     } catch (std::exception& e) {
80712       {
80713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80714       };
80715     } catch (Dali::DaliException e) {
80716       {
80717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80718       };
80719     } catch (...) {
80720       {
80721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80722       };
80723     }
80724   }
80725
80726   jresult = (void *)result;
80727   return jresult;
80728 }
80729
80730
80731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionReadPauseResumeSignal(void * jarg1) {
80732   void * jresult ;
80733   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80734   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80735
80736   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80737   {
80738     try {
80739       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionReadPauseResumeSignal();
80740     } catch (std::out_of_range& e) {
80741       {
80742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80743       };
80744     } catch (std::exception& e) {
80745       {
80746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80747       };
80748     } catch (Dali::DaliException e) {
80749       {
80750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80751       };
80752     } catch (...) {
80753       {
80754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80755       };
80756     }
80757   }
80758
80759   jresult = (void *)result;
80760   return jresult;
80761 }
80762
80763
80764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionStartStopSignal(void * jarg1) {
80765   void * jresult ;
80766   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80767   Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *result = 0 ;
80768
80769   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80770   {
80771     try {
80772       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionSignalType *) &(arg1)->ActionStartStopSignal();
80773     } catch (std::out_of_range& e) {
80774       {
80775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80776       };
80777     } catch (std::exception& e) {
80778       {
80779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80780       };
80781     } catch (Dali::DaliException e) {
80782       {
80783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80784       };
80785     } catch (...) {
80786       {
80787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80788       };
80789     }
80790   }
80791
80792   jresult = (void *)result;
80793   return jresult;
80794 }
80795
80796
80797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AccessibilityManager_ActionScrollSignal(void * jarg1) {
80798   void * jresult ;
80799   Dali::Toolkit::AccessibilityManager *arg1 = (Dali::Toolkit::AccessibilityManager *) 0 ;
80800   Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *result = 0 ;
80801
80802   arg1 = (Dali::Toolkit::AccessibilityManager *)jarg1;
80803   {
80804     try {
80805       result = (Dali::Toolkit::AccessibilityManager::AccessibilityActionScrollSignalType *) &(arg1)->ActionScrollSignal();
80806     } catch (std::out_of_range& e) {
80807       {
80808         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80809       };
80810     } catch (std::exception& e) {
80811       {
80812         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80813       };
80814     } catch (Dali::DaliException e) {
80815       {
80816         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80817       };
80818     } catch (...) {
80819       {
80820         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80821       };
80822     }
80823   }
80824
80825   jresult = (void *)result;
80826   return jresult;
80827 }
80828
80829
80830 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleManager() {
80831   void * jresult ;
80832   Dali::Toolkit::StyleManager *result = 0 ;
80833
80834   {
80835     try {
80836       result = (Dali::Toolkit::StyleManager *)new Dali::Toolkit::StyleManager();
80837     } catch (std::out_of_range& e) {
80838       {
80839         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80840       };
80841     } catch (std::exception& e) {
80842       {
80843         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80844       };
80845     } catch (Dali::DaliException e) {
80846       {
80847         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80848       };
80849     } catch (...) {
80850       {
80851         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80852       };
80853     }
80854   }
80855
80856   jresult = (void *)result;
80857   return jresult;
80858 }
80859
80860
80861 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleManager(void * jarg1) {
80862   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80863
80864   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80865   {
80866     try {
80867       delete arg1;
80868     } catch (std::out_of_range& e) {
80869       {
80870         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80871       };
80872     } catch (std::exception& e) {
80873       {
80874         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80875       };
80876     } catch (Dali::DaliException e) {
80877       {
80878         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80879       };
80880     } catch (...) {
80881       {
80882         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80883       };
80884     }
80885   }
80886
80887 }
80888
80889
80890 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_Get() {
80891   void * jresult ;
80892   Dali::Toolkit::StyleManager result;
80893
80894   {
80895     try {
80896       result = Dali::Toolkit::StyleManager::Get();
80897     } catch (std::out_of_range& e) {
80898       {
80899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
80900       };
80901     } catch (std::exception& e) {
80902       {
80903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
80904       };
80905     } catch (Dali::DaliException e) {
80906       {
80907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
80908       };
80909     } catch (...) {
80910       {
80911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
80912       };
80913     }
80914   }
80915
80916   jresult = new Dali::Toolkit::StyleManager((const Dali::Toolkit::StyleManager &)result);
80917   return jresult;
80918 }
80919
80920
80921 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyTheme(void * jarg1, char * jarg2) {
80922   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80923   std::string *arg2 = 0 ;
80924
80925   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80926   if (!jarg2) {
80927     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80928     return ;
80929   }
80930   std::string arg2_str(jarg2);
80931   arg2 = &arg2_str;
80932   {
80933     try {
80934       (arg1)->ApplyTheme((std::string const &)*arg2);
80935     } catch (std::out_of_range& e) {
80936       {
80937         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80938       };
80939     } catch (std::exception& e) {
80940       {
80941         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80942       };
80943     } catch (Dali::DaliException e) {
80944       {
80945         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80946       };
80947     } catch (...) {
80948       {
80949         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80950       };
80951     }
80952   }
80953
80954
80955   //argout typemap for const std::string&
80956
80957 }
80958
80959
80960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyDefaultTheme(void * jarg1) {
80961   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80962
80963   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80964   {
80965     try {
80966       (arg1)->ApplyDefaultTheme();
80967     } catch (std::out_of_range& e) {
80968       {
80969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
80970       };
80971     } catch (std::exception& e) {
80972       {
80973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
80974       };
80975     } catch (Dali::DaliException e) {
80976       {
80977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
80978       };
80979     } catch (...) {
80980       {
80981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
80982       };
80983     }
80984   }
80985
80986 }
80987
80988
80989 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_SetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
80990   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
80991   std::string *arg2 = 0 ;
80992   Dali::Property::Value *arg3 = 0 ;
80993
80994   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
80995   if (!jarg2) {
80996     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
80997     return ;
80998   }
80999   std::string arg2_str(jarg2);
81000   arg2 = &arg2_str;
81001   arg3 = (Dali::Property::Value *)jarg3;
81002   if (!arg3) {
81003     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value const & type is null", 0);
81004     return ;
81005   }
81006   {
81007     try {
81008       (arg1)->SetStyleConstant((std::string const &)*arg2,(Dali::Property::Value const &)*arg3);
81009     } catch (std::out_of_range& e) {
81010       {
81011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81012       };
81013     } catch (std::exception& e) {
81014       {
81015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81016       };
81017     } catch (Dali::DaliException e) {
81018       {
81019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81020       };
81021     } catch (...) {
81022       {
81023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81024       };
81025     }
81026   }
81027
81028
81029   //argout typemap for const std::string&
81030
81031 }
81032
81033
81034 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleManager_GetStyleConstant(void * jarg1, char * jarg2, void * jarg3) {
81035   unsigned int jresult ;
81036   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81037   std::string *arg2 = 0 ;
81038   Dali::Property::Value *arg3 = 0 ;
81039   bool result;
81040
81041   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81042   if (!jarg2) {
81043     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81044     return 0;
81045   }
81046   std::string arg2_str(jarg2);
81047   arg2 = &arg2_str;
81048   arg3 = (Dali::Property::Value *)jarg3;
81049   if (!arg3) {
81050     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Value & type is null", 0);
81051     return 0;
81052   }
81053   {
81054     try {
81055       result = (bool)(arg1)->GetStyleConstant((std::string const &)*arg2,*arg3);
81056     } catch (std::out_of_range& e) {
81057       {
81058         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81059       };
81060     } catch (std::exception& e) {
81061       {
81062         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81063       };
81064     } catch (Dali::DaliException e) {
81065       {
81066         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81067       };
81068     } catch (...) {
81069       {
81070         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81071       };
81072     }
81073   }
81074
81075   jresult = result;
81076
81077   //argout typemap for const std::string&
81078
81079   return jresult;
81080 }
81081
81082
81083 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleManager_ApplyStyle(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
81084   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81085   Dali::Toolkit::Control arg2 ;
81086   std::string *arg3 = 0 ;
81087   std::string *arg4 = 0 ;
81088   Dali::Toolkit::Control *argp2 ;
81089
81090   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81091   argp2 = (Dali::Toolkit::Control *)jarg2;
81092   if (!argp2) {
81093     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
81094     return ;
81095   }
81096   arg2 = *argp2;
81097   if (!jarg3) {
81098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81099     return ;
81100   }
81101   std::string arg3_str(jarg3);
81102   arg3 = &arg3_str;
81103   if (!jarg4) {
81104     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81105     return ;
81106   }
81107   std::string arg4_str(jarg4);
81108   arg4 = &arg4_str;
81109   {
81110     try {
81111       (arg1)->ApplyStyle(arg2,(std::string const &)*arg3,(std::string const &)*arg4);
81112     } catch (std::out_of_range& e) {
81113       {
81114         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81115       };
81116     } catch (std::exception& e) {
81117       {
81118         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81119       };
81120     } catch (Dali::DaliException e) {
81121       {
81122         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81123       };
81124     } catch (...) {
81125       {
81126         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81127       };
81128     }
81129   }
81130
81131
81132   //argout typemap for const std::string&
81133
81134
81135   //argout typemap for const std::string&
81136
81137 }
81138
81139
81140 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_StyleManager_StyleChangedSignal(void * jarg1) {
81141   void * jresult ;
81142   Dali::Toolkit::StyleManager *arg1 = (Dali::Toolkit::StyleManager *) 0 ;
81143   Dali::Toolkit::StyleManager::StyleChangedSignalType *result = 0 ;
81144
81145   arg1 = (Dali::Toolkit::StyleManager *)jarg1;
81146   {
81147     try {
81148       result = (Dali::Toolkit::StyleManager::StyleChangedSignalType *) &(arg1)->StyleChangedSignal();
81149     } catch (std::out_of_range& e) {
81150       {
81151         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81152       };
81153     } catch (std::exception& e) {
81154       {
81155         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81156       };
81157     } catch (Dali::DaliException e) {
81158       {
81159         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81160       };
81161     } catch (...) {
81162       {
81163         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81164       };
81165     }
81166   }
81167
81168   jresult = (void *)result;
81169   return jresult;
81170 }
81171
81172
81173 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_LOWER_BOUND_get() {
81174   int jresult ;
81175   int result;
81176
81177   result = (int)Dali::Toolkit::Slider::Property::LOWER_BOUND;
81178   jresult = (int)result;
81179   return jresult;
81180 }
81181
81182
81183 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_UPPER_BOUND_get() {
81184   int jresult ;
81185   int result;
81186
81187   result = (int)Dali::Toolkit::Slider::Property::UPPER_BOUND;
81188   jresult = (int)result;
81189   return jresult;
81190 }
81191
81192
81193 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_get() {
81194   int jresult ;
81195   int result;
81196
81197   result = (int)Dali::Toolkit::Slider::Property::VALUE;
81198   jresult = (int)result;
81199   return jresult;
81200 }
81201
81202
81203 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_TRACK_VISUAL_get() {
81204   int jresult ;
81205   int result;
81206
81207   result = (int)Dali::Toolkit::Slider::Property::TRACK_VISUAL;
81208   jresult = (int)result;
81209   return jresult;
81210 }
81211
81212
81213 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_HANDLE_VISUAL_get() {
81214   int jresult ;
81215   int result;
81216
81217   result = (int)Dali::Toolkit::Slider::Property::HANDLE_VISUAL;
81218   jresult = (int)result;
81219   return jresult;
81220 }
81221
81222
81223 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_PROGRESS_VISUAL_get() {
81224   int jresult ;
81225   int result;
81226
81227   result = (int)Dali::Toolkit::Slider::Property::PROGRESS_VISUAL;
81228   jresult = (int)result;
81229   return jresult;
81230 }
81231
81232
81233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_VISUAL_get() {
81234   int jresult ;
81235   int result;
81236
81237   result = (int)Dali::Toolkit::Slider::Property::POPUP_VISUAL;
81238   jresult = (int)result;
81239   return jresult;
81240 }
81241
81242
81243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_POPUP_ARROW_VISUAL_get() {
81244   int jresult ;
81245   int result;
81246
81247   result = (int)Dali::Toolkit::Slider::Property::POPUP_ARROW_VISUAL;
81248   jresult = (int)result;
81249   return jresult;
81250 }
81251
81252
81253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_DISABLED_COLOR_get() {
81254   int jresult ;
81255   int result;
81256
81257   result = (int)Dali::Toolkit::Slider::Property::DISABLED_COLOR;
81258   jresult = (int)result;
81259   return jresult;
81260 }
81261
81262
81263 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_VALUE_PRECISION_get() {
81264   int jresult ;
81265   int result;
81266
81267   result = (int)Dali::Toolkit::Slider::Property::VALUE_PRECISION;
81268   jresult = (int)result;
81269   return jresult;
81270 }
81271
81272
81273 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_POPUP_get() {
81274   int jresult ;
81275   int result;
81276
81277   result = (int)Dali::Toolkit::Slider::Property::SHOW_POPUP;
81278   jresult = (int)result;
81279   return jresult;
81280 }
81281
81282
81283 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SHOW_VALUE_get() {
81284   int jresult ;
81285   int result;
81286
81287   result = (int)Dali::Toolkit::Slider::Property::SHOW_VALUE;
81288   jresult = (int)result;
81289   return jresult;
81290 }
81291
81292
81293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARKS_get() {
81294   int jresult ;
81295   int result;
81296
81297   result = (int)Dali::Toolkit::Slider::Property::MARKS;
81298   jresult = (int)result;
81299   return jresult;
81300 }
81301
81302
81303 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_SNAP_TO_MARKS_get() {
81304   int jresult ;
81305   int result;
81306
81307   result = (int)Dali::Toolkit::Slider::Property::SNAP_TO_MARKS;
81308   jresult = (int)result;
81309   return jresult;
81310 }
81311
81312
81313 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Slider_Property_MARK_TOLERANCE_get() {
81314   int jresult ;
81315   int result;
81316
81317   result = (int)Dali::Toolkit::Slider::Property::MARK_TOLERANCE;
81318   jresult = (int)result;
81319   return jresult;
81320 }
81321
81322
81323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider_Property() {
81324   void * jresult ;
81325   Dali::Toolkit::Slider::Property *result = 0 ;
81326
81327   {
81328     try {
81329       result = (Dali::Toolkit::Slider::Property *)new Dali::Toolkit::Slider::Property();
81330     } catch (std::out_of_range& e) {
81331       {
81332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81333       };
81334     } catch (std::exception& e) {
81335       {
81336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81337       };
81338     } catch (Dali::DaliException e) {
81339       {
81340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81341       };
81342     } catch (...) {
81343       {
81344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81345       };
81346     }
81347   }
81348
81349   jresult = (void *)result;
81350   return jresult;
81351 }
81352
81353
81354 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider_Property(void * jarg1) {
81355   Dali::Toolkit::Slider::Property *arg1 = (Dali::Toolkit::Slider::Property *) 0 ;
81356
81357   arg1 = (Dali::Toolkit::Slider::Property *)jarg1;
81358   {
81359     try {
81360       delete arg1;
81361     } catch (std::out_of_range& e) {
81362       {
81363         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81364       };
81365     } catch (std::exception& e) {
81366       {
81367         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81368       };
81369     } catch (Dali::DaliException e) {
81370       {
81371         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81372       };
81373     } catch (...) {
81374       {
81375         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81376       };
81377     }
81378   }
81379
81380 }
81381
81382
81383 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_New() {
81384   void * jresult ;
81385   Dali::Toolkit::Slider result;
81386
81387   {
81388     try {
81389       result = Dali::Toolkit::Slider::New();
81390     } catch (std::out_of_range& e) {
81391       {
81392         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81393       };
81394     } catch (std::exception& e) {
81395       {
81396         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81397       };
81398     } catch (Dali::DaliException e) {
81399       {
81400         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81401       };
81402     } catch (...) {
81403       {
81404         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81405       };
81406     }
81407   }
81408
81409   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81410   return jresult;
81411 }
81412
81413
81414 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_0() {
81415   void * jresult ;
81416   Dali::Toolkit::Slider *result = 0 ;
81417
81418   {
81419     try {
81420       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider();
81421     } catch (std::out_of_range& e) {
81422       {
81423         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81424       };
81425     } catch (std::exception& e) {
81426       {
81427         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81428       };
81429     } catch (Dali::DaliException e) {
81430       {
81431         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81432       };
81433     } catch (...) {
81434       {
81435         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81436       };
81437     }
81438   }
81439
81440   jresult = (void *)result;
81441   return jresult;
81442 }
81443
81444
81445 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Slider__SWIG_1(void * jarg1) {
81446   void * jresult ;
81447   Dali::Toolkit::Slider *arg1 = 0 ;
81448   Dali::Toolkit::Slider *result = 0 ;
81449
81450   arg1 = (Dali::Toolkit::Slider *)jarg1;
81451   if (!arg1) {
81452     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81453     return 0;
81454   }
81455   {
81456     try {
81457       result = (Dali::Toolkit::Slider *)new Dali::Toolkit::Slider((Dali::Toolkit::Slider const &)*arg1);
81458     } catch (std::out_of_range& e) {
81459       {
81460         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81461       };
81462     } catch (std::exception& e) {
81463       {
81464         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81465       };
81466     } catch (Dali::DaliException e) {
81467       {
81468         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81469       };
81470     } catch (...) {
81471       {
81472         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81473       };
81474     }
81475   }
81476
81477   jresult = (void *)result;
81478   return jresult;
81479 }
81480
81481
81482 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_Assign(void * jarg1, void * jarg2) {
81483   void * jresult ;
81484   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81485   Dali::Toolkit::Slider *arg2 = 0 ;
81486   Dali::Toolkit::Slider *result = 0 ;
81487
81488   arg1 = (Dali::Toolkit::Slider *)jarg1;
81489   arg2 = (Dali::Toolkit::Slider *)jarg2;
81490   if (!arg2) {
81491     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Slider const & type is null", 0);
81492     return 0;
81493   }
81494   {
81495     try {
81496       result = (Dali::Toolkit::Slider *) &(arg1)->operator =((Dali::Toolkit::Slider const &)*arg2);
81497     } catch (std::out_of_range& e) {
81498       {
81499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81500       };
81501     } catch (std::exception& e) {
81502       {
81503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81504       };
81505     } catch (Dali::DaliException e) {
81506       {
81507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81508       };
81509     } catch (...) {
81510       {
81511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81512       };
81513     }
81514   }
81515
81516   jresult = (void *)result;
81517   return jresult;
81518 }
81519
81520
81521 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Slider(void * jarg1) {
81522   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81523
81524   arg1 = (Dali::Toolkit::Slider *)jarg1;
81525   {
81526     try {
81527       delete arg1;
81528     } catch (std::out_of_range& e) {
81529       {
81530         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81531       };
81532     } catch (std::exception& e) {
81533       {
81534         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81535       };
81536     } catch (Dali::DaliException e) {
81537       {
81538         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81539       };
81540     } catch (...) {
81541       {
81542         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81543       };
81544     }
81545   }
81546
81547 }
81548
81549
81550 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_DownCast(void * jarg1) {
81551   void * jresult ;
81552   Dali::BaseHandle arg1 ;
81553   Dali::BaseHandle *argp1 ;
81554   Dali::Toolkit::Slider result;
81555
81556   argp1 = (Dali::BaseHandle *)jarg1;
81557   if (!argp1) {
81558     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
81559     return 0;
81560   }
81561   arg1 = *argp1;
81562   {
81563     try {
81564       result = Dali::Toolkit::Slider::DownCast(arg1);
81565     } catch (std::out_of_range& e) {
81566       {
81567         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81568       };
81569     } catch (std::exception& e) {
81570       {
81571         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81572       };
81573     } catch (Dali::DaliException e) {
81574       {
81575         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81576       };
81577     } catch (...) {
81578       {
81579         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81580       };
81581     }
81582   }
81583
81584   jresult = new Dali::Toolkit::Slider((const Dali::Toolkit::Slider &)result);
81585   return jresult;
81586 }
81587
81588
81589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_ValueChangedSignal(void * jarg1) {
81590   void * jresult ;
81591   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81592   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81593
81594   arg1 = (Dali::Toolkit::Slider *)jarg1;
81595   {
81596     try {
81597       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
81598     } catch (std::out_of_range& e) {
81599       {
81600         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81601       };
81602     } catch (std::exception& e) {
81603       {
81604         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81605       };
81606     } catch (Dali::DaliException e) {
81607       {
81608         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81609       };
81610     } catch (...) {
81611       {
81612         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81613       };
81614     }
81615   }
81616
81617   jresult = (void *)result;
81618   return jresult;
81619 }
81620
81621
81622 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_SlidingFinishedSignal(void * jarg1) {
81623   void * jresult ;
81624   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81625   Dali::Toolkit::Slider::ValueChangedSignalType *result = 0 ;
81626
81627   arg1 = (Dali::Toolkit::Slider *)jarg1;
81628   {
81629     try {
81630       result = (Dali::Toolkit::Slider::ValueChangedSignalType *) &(arg1)->SlidingFinishedSignal();
81631     } catch (std::out_of_range& e) {
81632       {
81633         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81634       };
81635     } catch (std::exception& e) {
81636       {
81637         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81638       };
81639     } catch (Dali::DaliException e) {
81640       {
81641         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81642       };
81643     } catch (...) {
81644       {
81645         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81646       };
81647     }
81648   }
81649
81650   jresult = (void *)result;
81651   return jresult;
81652 }
81653
81654
81655 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Slider_MarkReachedSignal(void * jarg1) {
81656   void * jresult ;
81657   Dali::Toolkit::Slider *arg1 = (Dali::Toolkit::Slider *) 0 ;
81658   Dali::Toolkit::Slider::MarkReachedSignalType *result = 0 ;
81659
81660   arg1 = (Dali::Toolkit::Slider *)jarg1;
81661   {
81662     try {
81663       result = (Dali::Toolkit::Slider::MarkReachedSignalType *) &(arg1)->MarkReachedSignal();
81664     } catch (std::out_of_range& e) {
81665       {
81666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81667       };
81668     } catch (std::exception& e) {
81669       {
81670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81671       };
81672     } catch (Dali::DaliException e) {
81673       {
81674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81675       };
81676     } catch (...) {
81677       {
81678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81679       };
81680     }
81681   }
81682
81683   jresult = (void *)result;
81684   return jresult;
81685 }
81686
81687
81688 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VIDEO_get() {
81689   int jresult ;
81690   int result;
81691
81692   result = (int)Dali::Toolkit::VideoView::Property::VIDEO;
81693   jresult = (int)result;
81694   return jresult;
81695 }
81696
81697
81698 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_LOOPING_get() {
81699   int jresult ;
81700   int result;
81701
81702   result = (int)Dali::Toolkit::VideoView::Property::LOOPING;
81703   jresult = (int)result;
81704   return jresult;
81705 }
81706
81707
81708 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_MUTED_get() {
81709   int jresult ;
81710   int result;
81711
81712   result = (int)Dali::Toolkit::VideoView::Property::MUTED;
81713   jresult = (int)result;
81714   return jresult;
81715 }
81716
81717
81718 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_VOLUME_get() {
81719   int jresult ;
81720   int result;
81721
81722   result = (int)Dali::Toolkit::VideoView::Property::VOLUME;
81723   jresult = (int)result;
81724   return jresult;
81725 }
81726
81727
81728 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VideoView_Property_UNDERLAY_get() {
81729   int result;
81730
81731   result = (int)Dali::Toolkit::VideoView::Property::UNDERLAY;
81732
81733   return result;
81734 }
81735
81736
81737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView_Property() {
81738   void * jresult ;
81739   Dali::Toolkit::VideoView::Property *result = 0 ;
81740
81741   {
81742     try {
81743       result = (Dali::Toolkit::VideoView::Property *)new Dali::Toolkit::VideoView::Property();
81744     } catch (std::out_of_range& e) {
81745       {
81746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81747       };
81748     } catch (std::exception& e) {
81749       {
81750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81751       };
81752     } catch (Dali::DaliException e) {
81753       {
81754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81755       };
81756     } catch (...) {
81757       {
81758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81759       };
81760     }
81761   }
81762
81763   jresult = (void *)result;
81764   return jresult;
81765 }
81766
81767
81768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView_Property(void * jarg1) {
81769   Dali::Toolkit::VideoView::Property *arg1 = (Dali::Toolkit::VideoView::Property *) 0 ;
81770
81771   arg1 = (Dali::Toolkit::VideoView::Property *)jarg1;
81772   {
81773     try {
81774       delete arg1;
81775     } catch (std::out_of_range& e) {
81776       {
81777         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81778       };
81779     } catch (std::exception& e) {
81780       {
81781         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81782       };
81783     } catch (Dali::DaliException e) {
81784       {
81785         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81786       };
81787     } catch (...) {
81788       {
81789         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81790       };
81791     }
81792   }
81793
81794 }
81795
81796
81797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_0() {
81798   void * jresult ;
81799   Dali::Toolkit::VideoView result;
81800
81801   {
81802     try {
81803       result = Dali::Toolkit::VideoView::New();
81804     } catch (std::out_of_range& e) {
81805       {
81806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81807       };
81808     } catch (std::exception& e) {
81809       {
81810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81811       };
81812     } catch (Dali::DaliException e) {
81813       {
81814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81815       };
81816     } catch (...) {
81817       {
81818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81819       };
81820     }
81821   }
81822
81823   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81824   return jresult;
81825 }
81826
81827
81828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_1(char * jarg1) {
81829   void * jresult ;
81830   std::string *arg1 = 0 ;
81831   Dali::Toolkit::VideoView result;
81832
81833   if (!jarg1) {
81834     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81835     return 0;
81836   }
81837   std::string arg1_str(jarg1);
81838   arg1 = &arg1_str;
81839   {
81840     try {
81841       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1);
81842     } catch (std::out_of_range& e) {
81843       {
81844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81845       };
81846     } catch (std::exception& e) {
81847       {
81848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81849       };
81850     } catch (Dali::DaliException e) {
81851       {
81852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81853       };
81854     } catch (...) {
81855       {
81856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81857       };
81858     }
81859   }
81860
81861   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81862
81863   //argout typemap for const std::string&
81864
81865   return jresult;
81866 }
81867
81868
81869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_2(bool swCodec) {
81870   void * jresult ;
81871   Dali::Toolkit::VideoView result;
81872   {
81873     try {
81874       result = Dali::Toolkit::VideoView::New(swCodec);
81875     } catch (std::out_of_range& e) {
81876       {
81877         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81878       };
81879     } catch (std::exception& e) {
81880       {
81881         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81882       };
81883     } catch (Dali::DaliException e) {
81884       {
81885         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81886       };
81887     } catch (...) {
81888       {
81889         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81890       };
81891     }
81892   }
81893
81894   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81895
81896   //argout typemap for const std::string&
81897
81898   return jresult;
81899 }
81900
81901
81902 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_New__SWIG_3(char * jarg1, bool swCodec) {
81903   void * jresult ;
81904   std::string *arg1 = 0 ;
81905   Dali::Toolkit::VideoView result;
81906
81907   if (!jarg1) {
81908     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
81909     return 0;
81910   }
81911   std::string arg1_str(jarg1);
81912   arg1 = &arg1_str;
81913   {
81914     try {
81915       result = Dali::Toolkit::VideoView::New((std::string const &)*arg1, swCodec);
81916     } catch (std::out_of_range& e) {
81917       {
81918         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81919       };
81920     } catch (std::exception& e) {
81921       {
81922         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81923       };
81924     } catch (Dali::DaliException e) {
81925       {
81926         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81927       };
81928     } catch (...) {
81929       {
81930         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81931       };
81932     }
81933   }
81934
81935   jresult = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
81936
81937   //argout typemap for const std::string&
81938
81939   return jresult;
81940 }
81941
81942
81943 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_0() {
81944   void * jresult ;
81945   Dali::Toolkit::VideoView *result = 0 ;
81946
81947   {
81948     try {
81949       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView();
81950     } catch (std::out_of_range& e) {
81951       {
81952         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
81953       };
81954     } catch (std::exception& e) {
81955       {
81956         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
81957       };
81958     } catch (Dali::DaliException e) {
81959       {
81960         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
81961       };
81962     } catch (...) {
81963       {
81964         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
81965       };
81966     }
81967   }
81968
81969   jresult = (void *)result;
81970   return jresult;
81971 }
81972
81973
81974 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoView(void * jarg1) {
81975   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
81976
81977   arg1 = (Dali::Toolkit::VideoView *)jarg1;
81978   {
81979     try {
81980       delete arg1;
81981     } catch (std::out_of_range& e) {
81982       {
81983         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
81984       };
81985     } catch (std::exception& e) {
81986       {
81987         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
81988       };
81989     } catch (Dali::DaliException e) {
81990       {
81991         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
81992       };
81993     } catch (...) {
81994       {
81995         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
81996       };
81997     }
81998   }
81999
82000 }
82001
82002
82003 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoView__SWIG_1(void * jarg1) {
82004   void * jresult ;
82005   Dali::Toolkit::VideoView *arg1 = 0 ;
82006   Dali::Toolkit::VideoView *result = 0 ;
82007
82008   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82009   if (!arg1) {
82010     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82011     return 0;
82012   }
82013   {
82014     try {
82015       result = (Dali::Toolkit::VideoView *)new Dali::Toolkit::VideoView((Dali::Toolkit::VideoView const &)*arg1);
82016     } catch (std::out_of_range& e) {
82017       {
82018         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82019       };
82020     } catch (std::exception& e) {
82021       {
82022         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82023       };
82024     } catch (Dali::DaliException e) {
82025       {
82026         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82027       };
82028     } catch (...) {
82029       {
82030         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82031       };
82032     }
82033   }
82034
82035   jresult = (void *)result;
82036   return jresult;
82037 }
82038
82039
82040 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_Assign(void * jarg1, void * jarg2) {
82041   void * jresult ;
82042   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82043   Dali::Toolkit::VideoView *arg2 = 0 ;
82044   Dali::Toolkit::VideoView *result = 0 ;
82045
82046   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82047   arg2 = (Dali::Toolkit::VideoView *)jarg2;
82048   if (!arg2) {
82049     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView const & type is null", 0);
82050     return 0;
82051   }
82052   {
82053     try {
82054       result = (Dali::Toolkit::VideoView *) &(arg1)->operator =((Dali::Toolkit::VideoView const &)*arg2);
82055     } catch (std::out_of_range& e) {
82056       {
82057         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82058       };
82059     } catch (std::exception& e) {
82060       {
82061         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82062       };
82063     } catch (Dali::DaliException e) {
82064       {
82065         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82066       };
82067     } catch (...) {
82068       {
82069         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82070       };
82071     }
82072   }
82073
82074   jresult = (void *)result;
82075   return jresult;
82076 }
82077
82078
82079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_DownCast(void * jarg1) {
82080   void * jresult ;
82081   Dali::BaseHandle arg1 ;
82082   Dali::BaseHandle *argp1 ;
82083   Dali::Toolkit::VideoView result;
82084
82085   argp1 = (Dali::BaseHandle *)jarg1;
82086   if (!argp1) {
82087     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82088     return 0;
82089   }
82090   arg1 = *argp1;
82091   {
82092     try {
82093       result = Dali::Toolkit::VideoView::DownCast(arg1);
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 = new Dali::Toolkit::VideoView((const Dali::Toolkit::VideoView &)result);
82114   return jresult;
82115 }
82116
82117
82118 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Play(void * jarg1) {
82119   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82120
82121   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82122   {
82123     try {
82124       (arg1)->Play();
82125     } catch (std::out_of_range& e) {
82126       {
82127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82128       };
82129     } catch (std::exception& e) {
82130       {
82131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82132       };
82133     } catch (Dali::DaliException e) {
82134       {
82135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82136       };
82137     } catch (...) {
82138       {
82139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82140       };
82141     }
82142   }
82143
82144 }
82145
82146
82147 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Pause(void * jarg1) {
82148   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82149
82150   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82151   {
82152     try {
82153       (arg1)->Pause();
82154     } catch (std::out_of_range& e) {
82155       {
82156         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82157       };
82158     } catch (std::exception& e) {
82159       {
82160         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82161       };
82162     } catch (Dali::DaliException e) {
82163       {
82164         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82165       };
82166     } catch (...) {
82167       {
82168         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82169       };
82170     }
82171   }
82172
82173 }
82174
82175
82176 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Stop(void * jarg1) {
82177   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82178
82179   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82180   {
82181     try {
82182       (arg1)->Stop();
82183     } catch (std::out_of_range& e) {
82184       {
82185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82186       };
82187     } catch (std::exception& e) {
82188       {
82189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82190       };
82191     } catch (Dali::DaliException e) {
82192       {
82193         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82194       };
82195     } catch (...) {
82196       {
82197         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82198       };
82199     }
82200   }
82201
82202 }
82203
82204
82205 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Forward(void * jarg1, int jarg2) {
82206   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82207   int arg2 ;
82208
82209   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82210   arg2 = (int)jarg2;
82211   {
82212     try {
82213       (arg1)->Forward(arg2);
82214     } catch (std::out_of_range& e) {
82215       {
82216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82217       };
82218     } catch (std::exception& e) {
82219       {
82220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82221       };
82222     } catch (Dali::DaliException e) {
82223       {
82224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82225       };
82226     } catch (...) {
82227       {
82228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82229       };
82230     }
82231   }
82232
82233 }
82234
82235
82236 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoView_Backward(void * jarg1, int jarg2) {
82237   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82238   int arg2 ;
82239
82240   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82241   arg2 = (int)jarg2;
82242   {
82243     try {
82244       (arg1)->Backward(arg2);
82245     } catch (std::out_of_range& e) {
82246       {
82247         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82248       };
82249     } catch (std::exception& e) {
82250       {
82251         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82252       };
82253     } catch (Dali::DaliException e) {
82254       {
82255         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82256       };
82257     } catch (...) {
82258       {
82259         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82260       };
82261     }
82262   }
82263
82264 }
82265
82266
82267 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_FinishedSignal(void * jarg1) {
82268   void * jresult ;
82269   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *) 0 ;
82270   Dali::Toolkit::VideoView::VideoViewSignalType *result = 0 ;
82271
82272   arg1 = (Dali::Toolkit::VideoView *)jarg1;
82273   {
82274     try {
82275       result = (Dali::Toolkit::VideoView::VideoViewSignalType *) &(arg1)->FinishedSignal();
82276     } catch (std::out_of_range& e) {
82277       {
82278         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82279       };
82280     } catch (std::exception& e) {
82281       {
82282         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82283       };
82284     } catch (Dali::DaliException e) {
82285       {
82286         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82287       };
82288     } catch (...) {
82289       {
82290         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82291       };
82292     }
82293   }
82294
82295   jresult = (void *)result;
82296   return jresult;
82297 }
82298
82299 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VideoView_GetNativePlayerHandle( void * jarg1 )
82300 {
82301   Dali::Toolkit::VideoView *arg1 = (Dali::Toolkit::VideoView *)jarg1;
82302   if( arg1 == nullptr )
82303   {
82304     DALI_LOG_ERROR("VideoView is nullptr!");
82305     return nullptr;
82306   }
82307   void * ret = nullptr;
82308   {
82309     try{
82310
82311       Dali::Any result = Toolkit::DevelVideoView::GetMediaPlayer( *arg1 );
82312       ret = Dali::AnyCast< void * >( result );
82313
82314     } catch (std::out_of_range& e) {
82315       {
82316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82317       };
82318     } catch (std::exception& e) {
82319       {
82320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82321       };
82322     } catch (Dali::DaliException e) {
82323       {
82324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82325       };
82326     } catch (...) {
82327       {
82328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82329       };
82330     }
82331   }
82332   return ret;
82333 }
82334
82335
82336 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TITLE_get() {
82337   int jresult ;
82338   int result;
82339
82340   result = (int)Dali::Toolkit::Popup::Property::TITLE;
82341   jresult = (int)result;
82342   return jresult;
82343 }
82344
82345
82346 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTENT_get() {
82347   int jresult ;
82348   int result;
82349
82350   result = (int)Dali::Toolkit::Popup::Property::CONTENT;
82351   jresult = (int)result;
82352   return jresult;
82353 }
82354
82355
82356 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_FOOTER_get() {
82357   int jresult ;
82358   int result;
82359
82360   result = (int)Dali::Toolkit::Popup::Property::FOOTER;
82361   jresult = (int)result;
82362   return jresult;
82363 }
82364
82365
82366 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_DISPLAY_STATE_get() {
82367   int jresult ;
82368   int result;
82369
82370   result = (int)Dali::Toolkit::Popup::Property::DISPLAY_STATE;
82371   jresult = (int)result;
82372   return jresult;
82373 }
82374
82375
82376 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TOUCH_TRANSPARENT_get() {
82377   int jresult ;
82378   int result;
82379
82380   result = (int)Dali::Toolkit::Popup::Property::TOUCH_TRANSPARENT;
82381   jresult = (int)result;
82382   return jresult;
82383 }
82384
82385
82386 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_VISIBILITY_get() {
82387   int jresult ;
82388   int result;
82389
82390   result = (int)Dali::Toolkit::Popup::Property::TAIL_VISIBILITY;
82391   jresult = (int)result;
82392   return jresult;
82393 }
82394
82395
82396 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_POSITION_get() {
82397   int jresult ;
82398   int result;
82399
82400   result = (int)Dali::Toolkit::Popup::Property::TAIL_POSITION;
82401   jresult = (int)result;
82402   return jresult;
82403 }
82404
82405
82406 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_CONTEXTUAL_MODE_get() {
82407   int jresult ;
82408   int result;
82409
82410   result = (int)Dali::Toolkit::Popup::Property::CONTEXTUAL_MODE;
82411   jresult = (int)result;
82412   return jresult;
82413 }
82414
82415
82416 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_DURATION_get() {
82417   int jresult ;
82418   int result;
82419
82420   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_DURATION;
82421   jresult = (int)result;
82422   return jresult;
82423 }
82424
82425
82426 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ANIMATION_MODE_get() {
82427   int jresult ;
82428   int result;
82429
82430   result = (int)Dali::Toolkit::Popup::Property::ANIMATION_MODE;
82431   jresult = (int)result;
82432   return jresult;
82433 }
82434
82435
82436 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_ENTRY_ANIMATION_get() {
82437   int jresult ;
82438   int result;
82439
82440   result = (int)Dali::Toolkit::Popup::Property::ENTRY_ANIMATION;
82441   jresult = (int)result;
82442   return jresult;
82443 }
82444
82445
82446 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_EXIT_ANIMATION_get() {
82447   int jresult ;
82448   int result;
82449
82450   result = (int)Dali::Toolkit::Popup::Property::EXIT_ANIMATION;
82451   jresult = (int)result;
82452   return jresult;
82453 }
82454
82455
82456 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_AUTO_HIDE_DELAY_get() {
82457   int jresult ;
82458   int result;
82459
82460   result = (int)Dali::Toolkit::Popup::Property::AUTO_HIDE_DELAY;
82461   jresult = (int)result;
82462   return jresult;
82463 }
82464
82465
82466 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_ENABLED_get() {
82467   int jresult ;
82468   int result;
82469
82470   result = (int)Dali::Toolkit::Popup::Property::BACKING_ENABLED;
82471   jresult = (int)result;
82472   return jresult;
82473 }
82474
82475
82476 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_BACKING_COLOR_get() {
82477   int jresult ;
82478   int result;
82479
82480   result = (int)Dali::Toolkit::Popup::Property::BACKING_COLOR;
82481   jresult = (int)result;
82482   return jresult;
82483 }
82484
82485
82486 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_IMAGE_get() {
82487   int jresult ;
82488   int result;
82489
82490   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_IMAGE;
82491   jresult = (int)result;
82492   return jresult;
82493 }
82494
82495
82496 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_POPUP_BACKGROUND_BORDER_get() {
82497   int jresult ;
82498   int result;
82499
82500   result = (int)Dali::Toolkit::Popup::Property::POPUP_BACKGROUND_BORDER;
82501   jresult = (int)result;
82502   return jresult;
82503 }
82504
82505
82506 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_UP_IMAGE_get() {
82507   int jresult ;
82508   int result;
82509
82510   result = (int)Dali::Toolkit::Popup::Property::TAIL_UP_IMAGE;
82511   jresult = (int)result;
82512   return jresult;
82513 }
82514
82515
82516 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_DOWN_IMAGE_get() {
82517   int jresult ;
82518   int result;
82519
82520   result = (int)Dali::Toolkit::Popup::Property::TAIL_DOWN_IMAGE;
82521   jresult = (int)result;
82522   return jresult;
82523 }
82524
82525
82526 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_LEFT_IMAGE_get() {
82527   int jresult ;
82528   int result;
82529
82530   result = (int)Dali::Toolkit::Popup::Property::TAIL_LEFT_IMAGE;
82531   jresult = (int)result;
82532   return jresult;
82533 }
82534
82535
82536 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_Property_TAIL_RIGHT_IMAGE_get() {
82537   int jresult ;
82538   int result;
82539
82540   result = (int)Dali::Toolkit::Popup::Property::TAIL_RIGHT_IMAGE;
82541   jresult = (int)result;
82542   return jresult;
82543 }
82544
82545
82546 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup_Property() {
82547   void * jresult ;
82548   Dali::Toolkit::Popup::Property *result = 0 ;
82549
82550   {
82551     try {
82552       result = (Dali::Toolkit::Popup::Property *)new Dali::Toolkit::Popup::Property();
82553     } catch (std::out_of_range& e) {
82554       {
82555         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82556       };
82557     } catch (std::exception& e) {
82558       {
82559         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82560       };
82561     } catch (Dali::DaliException e) {
82562       {
82563         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82564       };
82565     } catch (...) {
82566       {
82567         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82568       };
82569     }
82570   }
82571
82572   jresult = (void *)result;
82573   return jresult;
82574 }
82575
82576
82577 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup_Property(void * jarg1) {
82578   Dali::Toolkit::Popup::Property *arg1 = (Dali::Toolkit::Popup::Property *) 0 ;
82579
82580   arg1 = (Dali::Toolkit::Popup::Property *)jarg1;
82581   {
82582     try {
82583       delete arg1;
82584     } catch (std::out_of_range& e) {
82585       {
82586         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82587       };
82588     } catch (std::exception& e) {
82589       {
82590         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82591       };
82592     } catch (Dali::DaliException e) {
82593       {
82594         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82595       };
82596     } catch (...) {
82597       {
82598         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82599       };
82600     }
82601   }
82602
82603 }
82604
82605
82606 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_0() {
82607   void * jresult ;
82608   Dali::Toolkit::Popup *result = 0 ;
82609
82610   {
82611     try {
82612       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup();
82613     } catch (std::out_of_range& e) {
82614       {
82615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82616       };
82617     } catch (std::exception& e) {
82618       {
82619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82620       };
82621     } catch (Dali::DaliException e) {
82622       {
82623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82624       };
82625     } catch (...) {
82626       {
82627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82628       };
82629     }
82630   }
82631
82632   jresult = (void *)result;
82633   return jresult;
82634 }
82635
82636
82637 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_New() {
82638   void * jresult ;
82639   Dali::Toolkit::Popup result;
82640
82641   {
82642     try {
82643       result = Dali::Toolkit::Popup::New();
82644     } catch (std::out_of_range& e) {
82645       {
82646         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82647       };
82648     } catch (std::exception& e) {
82649       {
82650         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82651       };
82652     } catch (Dali::DaliException e) {
82653       {
82654         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82655       };
82656     } catch (...) {
82657       {
82658         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82659       };
82660     }
82661   }
82662
82663   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82664   return jresult;
82665 }
82666
82667
82668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Popup(void * jarg1) {
82669   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82670
82671   arg1 = (Dali::Toolkit::Popup *)jarg1;
82672   {
82673     try {
82674       delete arg1;
82675     } catch (std::out_of_range& e) {
82676       {
82677         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82678       };
82679     } catch (std::exception& e) {
82680       {
82681         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82682       };
82683     } catch (Dali::DaliException e) {
82684       {
82685         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82686       };
82687     } catch (...) {
82688       {
82689         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82690       };
82691     }
82692   }
82693
82694 }
82695
82696
82697 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Popup__SWIG_1(void * jarg1) {
82698   void * jresult ;
82699   Dali::Toolkit::Popup *arg1 = 0 ;
82700   Dali::Toolkit::Popup *result = 0 ;
82701
82702   arg1 = (Dali::Toolkit::Popup *)jarg1;
82703   if (!arg1) {
82704     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82705     return 0;
82706   }
82707   {
82708     try {
82709       result = (Dali::Toolkit::Popup *)new Dali::Toolkit::Popup((Dali::Toolkit::Popup const &)*arg1);
82710     } catch (std::out_of_range& e) {
82711       {
82712         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82713       };
82714     } catch (std::exception& e) {
82715       {
82716         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82717       };
82718     } catch (Dali::DaliException e) {
82719       {
82720         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82721       };
82722     } catch (...) {
82723       {
82724         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82725       };
82726     }
82727   }
82728
82729   jresult = (void *)result;
82730   return jresult;
82731 }
82732
82733
82734 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_Assign(void * jarg1, void * jarg2) {
82735   void * jresult ;
82736   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82737   Dali::Toolkit::Popup *arg2 = 0 ;
82738   Dali::Toolkit::Popup *result = 0 ;
82739
82740   arg1 = (Dali::Toolkit::Popup *)jarg1;
82741   arg2 = (Dali::Toolkit::Popup *)jarg2;
82742   if (!arg2) {
82743     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Popup const & type is null", 0);
82744     return 0;
82745   }
82746   {
82747     try {
82748       result = (Dali::Toolkit::Popup *) &(arg1)->operator =((Dali::Toolkit::Popup const &)*arg2);
82749     } catch (std::out_of_range& e) {
82750       {
82751         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82752       };
82753     } catch (std::exception& e) {
82754       {
82755         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82756       };
82757     } catch (Dali::DaliException e) {
82758       {
82759         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82760       };
82761     } catch (...) {
82762       {
82763         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82764       };
82765     }
82766   }
82767
82768   jresult = (void *)result;
82769   return jresult;
82770 }
82771
82772
82773 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_DownCast(void * jarg1) {
82774   void * jresult ;
82775   Dali::BaseHandle arg1 ;
82776   Dali::BaseHandle *argp1 ;
82777   Dali::Toolkit::Popup result;
82778
82779   argp1 = (Dali::BaseHandle *)jarg1;
82780   if (!argp1) {
82781     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
82782     return 0;
82783   }
82784   arg1 = *argp1;
82785   {
82786     try {
82787       result = Dali::Toolkit::Popup::DownCast(arg1);
82788     } catch (std::out_of_range& e) {
82789       {
82790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82791       };
82792     } catch (std::exception& e) {
82793       {
82794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82795       };
82796     } catch (Dali::DaliException e) {
82797       {
82798         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82799       };
82800     } catch (...) {
82801       {
82802         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82803       };
82804     }
82805   }
82806
82807   jresult = new Dali::Toolkit::Popup((const Dali::Toolkit::Popup &)result);
82808   return jresult;
82809 }
82810
82811
82812 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetTitle(void * jarg1, void * jarg2) {
82813   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82814   Dali::Actor arg2 ;
82815   Dali::Actor *argp2 ;
82816
82817   arg1 = (Dali::Toolkit::Popup *)jarg1;
82818   argp2 = (Dali::Actor *)jarg2;
82819   if (!argp2) {
82820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82821     return ;
82822   }
82823   arg2 = *argp2;
82824   {
82825     try {
82826       (arg1)->SetTitle(arg2);
82827     } catch (std::out_of_range& e) {
82828       {
82829         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82830       };
82831     } catch (std::exception& e) {
82832       {
82833         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82834       };
82835     } catch (Dali::DaliException e) {
82836       {
82837         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82838       };
82839     } catch (...) {
82840       {
82841         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82842       };
82843     }
82844   }
82845
82846 }
82847
82848
82849 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetTitle(void * jarg1) {
82850   void * jresult ;
82851   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82852   Dali::Actor result;
82853
82854   arg1 = (Dali::Toolkit::Popup *)jarg1;
82855   {
82856     try {
82857       result = ((Dali::Toolkit::Popup const *)arg1)->GetTitle();
82858     } catch (std::out_of_range& e) {
82859       {
82860         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82861       };
82862     } catch (std::exception& e) {
82863       {
82864         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82865       };
82866     } catch (Dali::DaliException e) {
82867       {
82868         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82869       };
82870     } catch (...) {
82871       {
82872         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82873       };
82874     }
82875   }
82876
82877   jresult = new Dali::Actor((const Dali::Actor &)result);
82878   return jresult;
82879 }
82880
82881
82882 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetContent(void * jarg1, void * jarg2) {
82883   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82884   Dali::Actor arg2 ;
82885   Dali::Actor *argp2 ;
82886
82887   arg1 = (Dali::Toolkit::Popup *)jarg1;
82888   argp2 = (Dali::Actor *)jarg2;
82889   if (!argp2) {
82890     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82891     return ;
82892   }
82893   arg2 = *argp2;
82894   {
82895     try {
82896       (arg1)->SetContent(arg2);
82897     } catch (std::out_of_range& e) {
82898       {
82899         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82900       };
82901     } catch (std::exception& e) {
82902       {
82903         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82904       };
82905     } catch (Dali::DaliException e) {
82906       {
82907         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82908       };
82909     } catch (...) {
82910       {
82911         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82912       };
82913     }
82914   }
82915
82916 }
82917
82918
82919 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetContent(void * jarg1) {
82920   void * jresult ;
82921   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82922   Dali::Actor result;
82923
82924   arg1 = (Dali::Toolkit::Popup *)jarg1;
82925   {
82926     try {
82927       result = ((Dali::Toolkit::Popup const *)arg1)->GetContent();
82928     } catch (std::out_of_range& e) {
82929       {
82930         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
82931       };
82932     } catch (std::exception& e) {
82933       {
82934         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
82935       };
82936     } catch (Dali::DaliException e) {
82937       {
82938         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
82939       };
82940     } catch (...) {
82941       {
82942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
82943       };
82944     }
82945   }
82946
82947   jresult = new Dali::Actor((const Dali::Actor &)result);
82948   return jresult;
82949 }
82950
82951
82952 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetFooter(void * jarg1, void * jarg2) {
82953   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82954   Dali::Actor arg2 ;
82955   Dali::Actor *argp2 ;
82956
82957   arg1 = (Dali::Toolkit::Popup *)jarg1;
82958   argp2 = (Dali::Actor *)jarg2;
82959   if (!argp2) {
82960     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
82961     return ;
82962   }
82963   arg2 = *argp2;
82964   {
82965     try {
82966       (arg1)->SetFooter(arg2);
82967     } catch (std::out_of_range& e) {
82968       {
82969         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
82970       };
82971     } catch (std::exception& e) {
82972       {
82973         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
82974       };
82975     } catch (Dali::DaliException e) {
82976       {
82977         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
82978       };
82979     } catch (...) {
82980       {
82981         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
82982       };
82983     }
82984   }
82985
82986 }
82987
82988
82989 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_GetFooter(void * jarg1) {
82990   void * jresult ;
82991   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
82992   Dali::Actor result;
82993
82994   arg1 = (Dali::Toolkit::Popup *)jarg1;
82995   {
82996     try {
82997       result = ((Dali::Toolkit::Popup const *)arg1)->GetFooter();
82998     } catch (std::out_of_range& e) {
82999       {
83000         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83001       };
83002     } catch (std::exception& e) {
83003       {
83004         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83005       };
83006     } catch (Dali::DaliException e) {
83007       {
83008         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83009       };
83010     } catch (...) {
83011       {
83012         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83013       };
83014     }
83015   }
83016
83017   jresult = new Dali::Actor((const Dali::Actor &)result);
83018   return jresult;
83019 }
83020
83021
83022 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Popup_SetDisplayState(void * jarg1, int jarg2) {
83023   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83024   Dali::Toolkit::Popup::DisplayState arg2 ;
83025
83026   arg1 = (Dali::Toolkit::Popup *)jarg1;
83027   arg2 = (Dali::Toolkit::Popup::DisplayState)jarg2;
83028   {
83029     try {
83030       (arg1)->SetDisplayState(arg2);
83031     } catch (std::out_of_range& e) {
83032       {
83033         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83034       };
83035     } catch (std::exception& e) {
83036       {
83037         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83038       };
83039     } catch (Dali::DaliException e) {
83040       {
83041         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83042       };
83043     } catch (...) {
83044       {
83045         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83046       };
83047     }
83048   }
83049
83050 }
83051
83052
83053 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_Popup_GetDisplayState(void * jarg1) {
83054   int jresult ;
83055   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83056   Dali::Toolkit::Popup::DisplayState result;
83057
83058   arg1 = (Dali::Toolkit::Popup *)jarg1;
83059   {
83060     try {
83061       result = (Dali::Toolkit::Popup::DisplayState)((Dali::Toolkit::Popup const *)arg1)->GetDisplayState();
83062     } catch (std::out_of_range& e) {
83063       {
83064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83065       };
83066     } catch (std::exception& e) {
83067       {
83068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83069       };
83070     } catch (Dali::DaliException e) {
83071       {
83072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83073       };
83074     } catch (...) {
83075       {
83076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83077       };
83078     }
83079   }
83080
83081   jresult = (int)result;
83082   return jresult;
83083 }
83084
83085
83086 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_OutsideTouchedSignal(void * jarg1) {
83087   void * jresult ;
83088   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83089   Dali::Toolkit::Popup::TouchedOutsideSignalType *result = 0 ;
83090
83091   arg1 = (Dali::Toolkit::Popup *)jarg1;
83092   {
83093     try {
83094       result = (Dali::Toolkit::Popup::TouchedOutsideSignalType *) &(arg1)->OutsideTouchedSignal();
83095     } catch (std::out_of_range& e) {
83096       {
83097         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83098       };
83099     } catch (std::exception& e) {
83100       {
83101         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83102       };
83103     } catch (Dali::DaliException e) {
83104       {
83105         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83106       };
83107     } catch (...) {
83108       {
83109         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83110       };
83111     }
83112   }
83113
83114   jresult = (void *)result;
83115   return jresult;
83116 }
83117
83118
83119 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShowingSignal(void * jarg1) {
83120   void * jresult ;
83121   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83122   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83123
83124   arg1 = (Dali::Toolkit::Popup *)jarg1;
83125   {
83126     try {
83127       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShowingSignal();
83128     } catch (std::out_of_range& e) {
83129       {
83130         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83131       };
83132     } catch (std::exception& e) {
83133       {
83134         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83135       };
83136     } catch (Dali::DaliException e) {
83137       {
83138         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83139       };
83140     } catch (...) {
83141       {
83142         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83143       };
83144     }
83145   }
83146
83147   jresult = (void *)result;
83148   return jresult;
83149 }
83150
83151
83152 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_ShownSignal(void * jarg1) {
83153   void * jresult ;
83154   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83155   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83156
83157   arg1 = (Dali::Toolkit::Popup *)jarg1;
83158   {
83159     try {
83160       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->ShownSignal();
83161     } catch (std::out_of_range& e) {
83162       {
83163         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83164       };
83165     } catch (std::exception& e) {
83166       {
83167         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83168       };
83169     } catch (Dali::DaliException e) {
83170       {
83171         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83172       };
83173     } catch (...) {
83174       {
83175         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83176       };
83177     }
83178   }
83179
83180   jresult = (void *)result;
83181   return jresult;
83182 }
83183
83184
83185 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HidingSignal(void * jarg1) {
83186   void * jresult ;
83187   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83188   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83189
83190   arg1 = (Dali::Toolkit::Popup *)jarg1;
83191   {
83192     try {
83193       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HidingSignal();
83194     } catch (std::out_of_range& e) {
83195       {
83196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83197       };
83198     } catch (std::exception& e) {
83199       {
83200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83201       };
83202     } catch (Dali::DaliException e) {
83203       {
83204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83205       };
83206     } catch (...) {
83207       {
83208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83209       };
83210     }
83211   }
83212
83213   jresult = (void *)result;
83214   return jresult;
83215 }
83216
83217
83218 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Popup_HiddenSignal(void * jarg1) {
83219   void * jresult ;
83220   Dali::Toolkit::Popup *arg1 = (Dali::Toolkit::Popup *) 0 ;
83221   Dali::Toolkit::Popup::DisplayStateChangeSignalType *result = 0 ;
83222
83223   arg1 = (Dali::Toolkit::Popup *)jarg1;
83224   {
83225     try {
83226       result = (Dali::Toolkit::Popup::DisplayStateChangeSignalType *) &(arg1)->HiddenSignal();
83227     } catch (std::out_of_range& e) {
83228       {
83229         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83230       };
83231     } catch (std::exception& e) {
83232       {
83233         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83234       };
83235     } catch (Dali::DaliException e) {
83236       {
83237         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83238       };
83239     } catch (...) {
83240       {
83241         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83242       };
83243     }
83244   }
83245
83246   jresult = (void *)result;
83247   return jresult;
83248 }
83249
83250
83251 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VALUE_get() {
83252   int jresult ;
83253   int result;
83254
83255   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VALUE;
83256   jresult = (int)result;
83257   return jresult;
83258 }
83259
83260
83261 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VALUE_get() {
83262   int jresult ;
83263   int result;
83264
83265   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VALUE;
83266   jresult = (int)result;
83267   return jresult;
83268 }
83269
83270
83271 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_get() {
83272   int jresult ;
83273   int result;
83274
83275   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE;
83276   jresult = (int)result;
83277   return jresult;
83278 }
83279
83280
83281 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_TRACK_VISUAL_get() {
83282   int jresult ;
83283   int result;
83284
83285   result = (int)Dali::Toolkit::ProgressBar::Property::TRACK_VISUAL;
83286   jresult = (int)result;
83287   return jresult;
83288 }
83289
83290
83291 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_PROGRESS_VISUAL_get() {
83292   int jresult ;
83293   int result;
83294
83295   result = (int)Dali::Toolkit::ProgressBar::Property::PROGRESS_VISUAL;
83296   jresult = (int)result;
83297   return jresult;
83298 }
83299
83300
83301 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_SECONDARY_PROGRESS_VISUAL_get() {
83302   int jresult ;
83303   int result;
83304
83305   result = (int)Dali::Toolkit::ProgressBar::Property::SECONDARY_PROGRESS_VISUAL;
83306   jresult = (int)result;
83307   return jresult;
83308 }
83309
83310
83311 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_get() {
83312   int jresult ;
83313   int result;
83314
83315   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL;
83316   jresult = (int)result;
83317   return jresult;
83318 }
83319
83320
83321 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_INDETERMINATE_VISUAL_ANIMATION_get() {
83322   int jresult ;
83323   int result;
83324
83325   result = (int)Dali::Toolkit::ProgressBar::Property::INDETERMINATE_VISUAL_ANIMATION;
83326   jresult = (int)result;
83327   return jresult;
83328 }
83329
83330
83331 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ProgressBar_Property_LABEL_VISUAL_get() {
83332   int jresult ;
83333   int result;
83334
83335   result = (int)Dali::Toolkit::ProgressBar::Property::LABEL_VISUAL;
83336   jresult = (int)result;
83337   return jresult;
83338 }
83339
83340
83341 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar_Property() {
83342   void * jresult ;
83343   Dali::Toolkit::ProgressBar::Property *result = 0 ;
83344
83345   {
83346     try {
83347       result = (Dali::Toolkit::ProgressBar::Property *)new Dali::Toolkit::ProgressBar::Property();
83348     } catch (std::out_of_range& e) {
83349       {
83350         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83351       };
83352     } catch (std::exception& e) {
83353       {
83354         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83355       };
83356     } catch (Dali::DaliException e) {
83357       {
83358         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83359       };
83360     } catch (...) {
83361       {
83362         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83363       };
83364     }
83365   }
83366
83367   jresult = (void *)result;
83368   return jresult;
83369 }
83370
83371
83372 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar_Property(void * jarg1) {
83373   Dali::Toolkit::ProgressBar::Property *arg1 = (Dali::Toolkit::ProgressBar::Property *) 0 ;
83374
83375   arg1 = (Dali::Toolkit::ProgressBar::Property *)jarg1;
83376   {
83377     try {
83378       delete arg1;
83379     } catch (std::out_of_range& e) {
83380       {
83381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83382       };
83383     } catch (std::exception& e) {
83384       {
83385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83386       };
83387     } catch (Dali::DaliException e) {
83388       {
83389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83390       };
83391     } catch (...) {
83392       {
83393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83394       };
83395     }
83396   }
83397
83398 }
83399
83400
83401 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_New() {
83402   void * jresult ;
83403   Dali::Toolkit::ProgressBar result;
83404
83405   {
83406     try {
83407       result = Dali::Toolkit::ProgressBar::New();
83408     } catch (std::out_of_range& e) {
83409       {
83410         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83411       };
83412     } catch (std::exception& e) {
83413       {
83414         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83415       };
83416     } catch (Dali::DaliException e) {
83417       {
83418         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83419       };
83420     } catch (...) {
83421       {
83422         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83423       };
83424     }
83425   }
83426
83427   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83428   return jresult;
83429 }
83430
83431
83432 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_0() {
83433   void * jresult ;
83434   Dali::Toolkit::ProgressBar *result = 0 ;
83435
83436   {
83437     try {
83438       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar();
83439     } catch (std::out_of_range& e) {
83440       {
83441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83442       };
83443     } catch (std::exception& e) {
83444       {
83445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83446       };
83447     } catch (Dali::DaliException e) {
83448       {
83449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83450       };
83451     } catch (...) {
83452       {
83453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83454       };
83455     }
83456   }
83457
83458   jresult = (void *)result;
83459   return jresult;
83460 }
83461
83462
83463 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBar__SWIG_1(void * jarg1) {
83464   void * jresult ;
83465   Dali::Toolkit::ProgressBar *arg1 = 0 ;
83466   Dali::Toolkit::ProgressBar *result = 0 ;
83467
83468   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83469   if (!arg1) {
83470     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83471     return 0;
83472   }
83473   {
83474     try {
83475       result = (Dali::Toolkit::ProgressBar *)new Dali::Toolkit::ProgressBar((Dali::Toolkit::ProgressBar const &)*arg1);
83476     } catch (std::out_of_range& e) {
83477       {
83478         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83479       };
83480     } catch (std::exception& e) {
83481       {
83482         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83483       };
83484     } catch (Dali::DaliException e) {
83485       {
83486         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83487       };
83488     } catch (...) {
83489       {
83490         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83491       };
83492     }
83493   }
83494
83495   jresult = (void *)result;
83496   return jresult;
83497 }
83498
83499
83500 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_Assign(void * jarg1, void * jarg2) {
83501   void * jresult ;
83502   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83503   Dali::Toolkit::ProgressBar *arg2 = 0 ;
83504   Dali::Toolkit::ProgressBar *result = 0 ;
83505
83506   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83507   arg2 = (Dali::Toolkit::ProgressBar *)jarg2;
83508   if (!arg2) {
83509     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ProgressBar const & type is null", 0);
83510     return 0;
83511   }
83512   {
83513     try {
83514       result = (Dali::Toolkit::ProgressBar *) &(arg1)->operator =((Dali::Toolkit::ProgressBar const &)*arg2);
83515     } catch (std::out_of_range& e) {
83516       {
83517         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83518       };
83519     } catch (std::exception& e) {
83520       {
83521         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83522       };
83523     } catch (Dali::DaliException e) {
83524       {
83525         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83526       };
83527     } catch (...) {
83528       {
83529         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83530       };
83531     }
83532   }
83533
83534   jresult = (void *)result;
83535   return jresult;
83536 }
83537
83538
83539 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBar(void * jarg1) {
83540   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83541
83542   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83543   {
83544     try {
83545       delete arg1;
83546     } catch (std::out_of_range& e) {
83547       {
83548         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83549       };
83550     } catch (std::exception& e) {
83551       {
83552         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83553       };
83554     } catch (Dali::DaliException e) {
83555       {
83556         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83557       };
83558     } catch (...) {
83559       {
83560         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83561       };
83562     }
83563   }
83564
83565 }
83566
83567
83568 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_DownCast(void * jarg1) {
83569   void * jresult ;
83570   Dali::BaseHandle arg1 ;
83571   Dali::BaseHandle *argp1 ;
83572   Dali::Toolkit::ProgressBar result;
83573
83574   argp1 = (Dali::BaseHandle *)jarg1;
83575   if (!argp1) {
83576     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83577     return 0;
83578   }
83579   arg1 = *argp1;
83580   {
83581     try {
83582       result = Dali::Toolkit::ProgressBar::DownCast(arg1);
83583     } catch (std::out_of_range& e) {
83584       {
83585         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83586       };
83587     } catch (std::exception& e) {
83588       {
83589         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83590       };
83591     } catch (Dali::DaliException e) {
83592       {
83593         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83594       };
83595     } catch (...) {
83596       {
83597         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83598       };
83599     }
83600   }
83601
83602   jresult = new Dali::Toolkit::ProgressBar((const Dali::Toolkit::ProgressBar &)result);
83603   return jresult;
83604 }
83605
83606
83607 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ProgressBar_ValueChangedSignal(void * jarg1) {
83608   void * jresult ;
83609   Dali::Toolkit::ProgressBar *arg1 = (Dali::Toolkit::ProgressBar *) 0 ;
83610   Dali::Toolkit::ProgressBar::ValueChangedSignalType *result = 0 ;
83611
83612   arg1 = (Dali::Toolkit::ProgressBar *)jarg1;
83613   {
83614     try {
83615       result = (Dali::Toolkit::ProgressBar::ValueChangedSignalType *) &(arg1)->ValueChangedSignal();
83616     } catch (std::out_of_range& e) {
83617       {
83618         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83619       };
83620     } catch (std::exception& e) {
83621       {
83622         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83623       };
83624     } catch (Dali::DaliException e) {
83625       {
83626         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83627       };
83628     } catch (...) {
83629       {
83630         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83631       };
83632     }
83633   }
83634
83635   jresult = (void *)result;
83636   return jresult;
83637 }
83638
83639
83640 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_0() {
83641   void * jresult ;
83642   Dali::Toolkit::GaussianBlurView *result = 0 ;
83643
83644   {
83645     try {
83646       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView();
83647     } catch (std::out_of_range& e) {
83648       {
83649         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83650       };
83651     } catch (std::exception& e) {
83652       {
83653         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83654       };
83655     } catch (Dali::DaliException e) {
83656       {
83657         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83658       };
83659     } catch (...) {
83660       {
83661         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83662       };
83663     }
83664   }
83665
83666   jresult = (void *)result;
83667   return jresult;
83668 }
83669
83670
83671 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurView__SWIG_1(void * jarg1) {
83672   void * jresult ;
83673   Dali::Toolkit::GaussianBlurView *arg1 = 0 ;
83674   Dali::Toolkit::GaussianBlurView *result = 0 ;
83675
83676   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83677   if (!arg1) {
83678     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83679     return 0;
83680   }
83681   {
83682     try {
83683       result = (Dali::Toolkit::GaussianBlurView *)new Dali::Toolkit::GaussianBlurView((Dali::Toolkit::GaussianBlurView const &)*arg1);
83684     } catch (std::out_of_range& e) {
83685       {
83686         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83687       };
83688     } catch (std::exception& e) {
83689       {
83690         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83691       };
83692     } catch (Dali::DaliException e) {
83693       {
83694         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83695       };
83696     } catch (...) {
83697       {
83698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83699       };
83700     }
83701   }
83702
83703   jresult = (void *)result;
83704   return jresult;
83705 }
83706
83707
83708 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_Assign(void * jarg1, void * jarg2) {
83709   void * jresult ;
83710   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83711   Dali::Toolkit::GaussianBlurView *arg2 = 0 ;
83712   Dali::Toolkit::GaussianBlurView *result = 0 ;
83713
83714   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83715   arg2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
83716   if (!arg2) {
83717     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::GaussianBlurView const & type is null", 0);
83718     return 0;
83719   }
83720   {
83721     try {
83722       result = (Dali::Toolkit::GaussianBlurView *) &(arg1)->operator =((Dali::Toolkit::GaussianBlurView const &)*arg2);
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 void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurView(void * jarg1) {
83748   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83749
83750   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83751   {
83752     try {
83753       delete arg1;
83754     } catch (std::out_of_range& e) {
83755       {
83756         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83757       };
83758     } catch (std::exception& e) {
83759       {
83760         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83761       };
83762     } catch (Dali::DaliException e) {
83763       {
83764         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83765       };
83766     } catch (...) {
83767       {
83768         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83769       };
83770     }
83771   }
83772
83773 }
83774
83775
83776 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_DownCast(void * jarg1) {
83777   void * jresult ;
83778   Dali::BaseHandle arg1 ;
83779   Dali::BaseHandle *argp1 ;
83780   Dali::Toolkit::GaussianBlurView result;
83781
83782   argp1 = (Dali::BaseHandle *)jarg1;
83783   if (!argp1) {
83784     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
83785     return 0;
83786   }
83787   arg1 = *argp1;
83788   {
83789     try {
83790       result = Dali::Toolkit::GaussianBlurView::DownCast(arg1);
83791     } catch (std::out_of_range& e) {
83792       {
83793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83794       };
83795     } catch (std::exception& e) {
83796       {
83797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83798       };
83799     } catch (Dali::DaliException e) {
83800       {
83801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83802       };
83803     } catch (...) {
83804       {
83805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83806       };
83807     }
83808   }
83809
83810   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83811   return jresult;
83812 }
83813
83814
83815 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_0() {
83816   void * jresult ;
83817   Dali::Toolkit::GaussianBlurView result;
83818
83819   {
83820     try {
83821       result = Dali::Toolkit::GaussianBlurView::New();
83822     } catch (std::out_of_range& e) {
83823       {
83824         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83825       };
83826     } catch (std::exception& e) {
83827       {
83828         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83829       };
83830     } catch (Dali::DaliException e) {
83831       {
83832         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83833       };
83834     } catch (...) {
83835       {
83836         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83837       };
83838     }
83839   }
83840
83841   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83842   return jresult;
83843 }
83844
83845
83846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_1(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5, unsigned int jarg6) {
83847   void * jresult ;
83848   unsigned int arg1 ;
83849   float arg2 ;
83850   Dali::Pixel::Format arg3 ;
83851   float arg4 ;
83852   float arg5 ;
83853   bool arg6 ;
83854   Dali::Toolkit::GaussianBlurView result;
83855
83856   arg1 = (unsigned int)jarg1;
83857   arg2 = (float)jarg2;
83858   arg3 = (Dali::Pixel::Format)jarg3;
83859   arg4 = (float)jarg4;
83860   arg5 = (float)jarg5;
83861   arg6 = jarg6 ? true : false;
83862   {
83863     try {
83864       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5,arg6);
83865     } catch (std::out_of_range& e) {
83866       {
83867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83868       };
83869     } catch (std::exception& e) {
83870       {
83871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83872       };
83873     } catch (Dali::DaliException e) {
83874       {
83875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83876       };
83877     } catch (...) {
83878       {
83879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83880       };
83881     }
83882   }
83883
83884   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83885   return jresult;
83886 }
83887
83888
83889 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_New__SWIG_2(unsigned int jarg1, float jarg2, int jarg3, float jarg4, float jarg5) {
83890   void * jresult ;
83891   unsigned int arg1 ;
83892   float arg2 ;
83893   Dali::Pixel::Format arg3 ;
83894   float arg4 ;
83895   float arg5 ;
83896   Dali::Toolkit::GaussianBlurView result;
83897
83898   arg1 = (unsigned int)jarg1;
83899   arg2 = (float)jarg2;
83900   arg3 = (Dali::Pixel::Format)jarg3;
83901   arg4 = (float)jarg4;
83902   arg5 = (float)jarg5;
83903   {
83904     try {
83905       result = Dali::Toolkit::GaussianBlurView::New(arg1,arg2,arg3,arg4,arg5);
83906     } catch (std::out_of_range& e) {
83907       {
83908         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
83909       };
83910     } catch (std::exception& e) {
83911       {
83912         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
83913       };
83914     } catch (Dali::DaliException e) {
83915       {
83916         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
83917       };
83918     } catch (...) {
83919       {
83920         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
83921       };
83922     }
83923   }
83924
83925   jresult = new Dali::Toolkit::GaussianBlurView((const Dali::Toolkit::GaussianBlurView &)result);
83926   return jresult;
83927 }
83928
83929
83930 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Add(void * jarg1, void * jarg2) {
83931   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83932   Dali::Actor arg2 ;
83933   Dali::Actor *argp2 ;
83934
83935   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83936   argp2 = (Dali::Actor *)jarg2;
83937   if (!argp2) {
83938     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83939     return ;
83940   }
83941   arg2 = *argp2;
83942   {
83943     try {
83944       (arg1)->Add(arg2);
83945     } catch (std::out_of_range& e) {
83946       {
83947         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83948       };
83949     } catch (std::exception& e) {
83950       {
83951         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83952       };
83953     } catch (Dali::DaliException e) {
83954       {
83955         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83956       };
83957     } catch (...) {
83958       {
83959         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83960       };
83961     }
83962   }
83963
83964 }
83965
83966
83967 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Remove(void * jarg1, void * jarg2) {
83968   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
83969   Dali::Actor arg2 ;
83970   Dali::Actor *argp2 ;
83971
83972   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
83973   argp2 = (Dali::Actor *)jarg2;
83974   if (!argp2) {
83975     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
83976     return ;
83977   }
83978   arg2 = *argp2;
83979   {
83980     try {
83981       (arg1)->Remove(arg2);
83982     } catch (std::out_of_range& e) {
83983       {
83984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
83985       };
83986     } catch (std::exception& e) {
83987       {
83988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
83989       };
83990     } catch (Dali::DaliException e) {
83991       {
83992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
83993       };
83994     } catch (...) {
83995       {
83996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
83997       };
83998     }
83999   }
84000
84001 }
84002
84003
84004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Activate(void * jarg1) {
84005   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84006
84007   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84008   {
84009     try {
84010       (arg1)->Activate();
84011     } catch (std::out_of_range& e) {
84012       {
84013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84014       };
84015     } catch (std::exception& e) {
84016       {
84017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84018       };
84019     } catch (Dali::DaliException e) {
84020       {
84021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84022       };
84023     } catch (...) {
84024       {
84025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84026       };
84027     }
84028   }
84029
84030 }
84031
84032
84033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_ActivateOnce(void * jarg1) {
84034   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84035
84036   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84037   {
84038     try {
84039       (arg1)->ActivateOnce();
84040     } catch (std::out_of_range& e) {
84041       {
84042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84043       };
84044     } catch (std::exception& e) {
84045       {
84046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84047       };
84048     } catch (Dali::DaliException e) {
84049       {
84050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84051       };
84052     } catch (...) {
84053       {
84054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84055       };
84056     }
84057   }
84058
84059 }
84060
84061
84062 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_Deactivate(void * jarg1) {
84063   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84064
84065   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84066   {
84067     try {
84068       (arg1)->Deactivate();
84069     } catch (std::out_of_range& e) {
84070       {
84071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84072       };
84073     } catch (std::exception& e) {
84074       {
84075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84076       };
84077     } catch (Dali::DaliException e) {
84078       {
84079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84080       };
84081     } catch (...) {
84082       {
84083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84084       };
84085     }
84086   }
84087
84088 }
84089
84090
84091 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetUserImageAndOutputRenderTarget(void * jarg1, void * jarg2, void * jarg3) {
84092   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84093   Dali::Texture arg2 ;
84094   Dali::FrameBuffer arg3 ;
84095   Dali::Texture *argp2 ;
84096   Dali::FrameBuffer *argp3 ;
84097
84098   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84099   argp2 = (Dali::Texture *)jarg2;
84100   if (!argp2) {
84101     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Texture", 0);
84102     return ;
84103   }
84104   arg2 = *argp2;
84105   argp3 = (Dali::FrameBuffer *)jarg3;
84106   if (!argp3) {
84107     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::FrameBuffer", 0);
84108     return ;
84109   }
84110   arg3 = *argp3;
84111   {
84112     try {
84113       (arg1)->SetUserImageAndOutputRenderTarget(arg2,arg3);
84114     } catch (std::out_of_range& e) {
84115       {
84116         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84117       };
84118     } catch (std::exception& e) {
84119       {
84120         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84121       };
84122     } catch (Dali::DaliException e) {
84123       {
84124         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84125       };
84126     } catch (...) {
84127       {
84128         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84129       };
84130     }
84131   }
84132
84133 }
84134
84135
84136 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurStrengthPropertyIndex(void * jarg1) {
84137   int jresult ;
84138   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84139   Dali::Property::Index result;
84140
84141   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84142   {
84143     try {
84144       result = (Dali::Property::Index)((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurStrengthPropertyIndex();
84145     } catch (std::out_of_range& e) {
84146       {
84147         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84148       };
84149     } catch (std::exception& e) {
84150       {
84151         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84152       };
84153     } catch (Dali::DaliException e) {
84154       {
84155         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84156       };
84157     } catch (...) {
84158       {
84159         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84160       };
84161     }
84162   }
84163
84164   jresult = result;
84165   return jresult;
84166 }
84167
84168
84169 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBlurredRenderTarget(void * jarg1) {
84170   void * jresult ;
84171   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84172   Dali::FrameBuffer result;
84173
84174   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84175   {
84176     try {
84177       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBlurredRenderTarget();
84178     } catch (std::out_of_range& e) {
84179       {
84180         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84181       };
84182     } catch (std::exception& e) {
84183       {
84184         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84185       };
84186     } catch (Dali::DaliException e) {
84187       {
84188         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84189       };
84190     } catch (...) {
84191       {
84192         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84193       };
84194     }
84195   }
84196
84197   jresult = new Dali::FrameBuffer((const Dali::FrameBuffer &)result);
84198   return jresult;
84199 }
84200
84201
84202 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurView_SetBackgroundColor(void * jarg1, void * jarg2) {
84203   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84204   Dali::Vector4 *arg2 = 0 ;
84205
84206   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84207   arg2 = (Dali::Vector4 *)jarg2;
84208   if (!arg2) {
84209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector4 const & type is null", 0);
84210     return ;
84211   }
84212   {
84213     try {
84214       (arg1)->SetBackgroundColor((Dali::Vector4 const &)*arg2);
84215     } catch (std::out_of_range& e) {
84216       {
84217         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84218       };
84219     } catch (std::exception& e) {
84220       {
84221         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84222       };
84223     } catch (Dali::DaliException e) {
84224       {
84225         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84226       };
84227     } catch (...) {
84228       {
84229         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84230       };
84231     }
84232   }
84233
84234 }
84235
84236
84237 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_GetBackgroundColor(void * jarg1) {
84238   void * jresult ;
84239   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84240   Dali::Vector4 result;
84241
84242   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84243   {
84244     try {
84245       result = ((Dali::Toolkit::GaussianBlurView const *)arg1)->GetBackgroundColor();
84246     } catch (std::out_of_range& e) {
84247       {
84248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84249       };
84250     } catch (std::exception& e) {
84251       {
84252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84253       };
84254     } catch (Dali::DaliException e) {
84255       {
84256         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84257       };
84258     } catch (...) {
84259       {
84260         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84261       };
84262     }
84263   }
84264
84265   jresult = new Dali::Vector4((const Dali::Vector4 &)result);
84266   return jresult;
84267 }
84268
84269
84270 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GaussianBlurView_FinishedSignal(void * jarg1) {
84271   void * jresult ;
84272   Dali::Toolkit::GaussianBlurView *arg1 = (Dali::Toolkit::GaussianBlurView *) 0 ;
84273   Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *result = 0 ;
84274
84275   arg1 = (Dali::Toolkit::GaussianBlurView *)jarg1;
84276   {
84277     try {
84278       result = (Dali::Toolkit::GaussianBlurView::GaussianBlurViewSignal *) &(arg1)->FinishedSignal();
84279     } catch (std::out_of_range& e) {
84280       {
84281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84282       };
84283     } catch (std::exception& e) {
84284       {
84285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84286       };
84287     } catch (Dali::DaliException e) {
84288       {
84289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84290       };
84291     } catch (...) {
84292       {
84293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84294       };
84295     }
84296   }
84297
84298   jresult = (void *)result;
84299   return jresult;
84300 }
84301
84302
84303 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageFactory(void * jarg1) {
84304   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84305
84306   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84307   {
84308     try {
84309       delete arg1;
84310     } catch (std::out_of_range& e) {
84311       {
84312         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84313       };
84314     } catch (std::exception& e) {
84315       {
84316         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84317       };
84318     } catch (Dali::DaliException e) {
84319       {
84320         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84321       };
84322     } catch (...) {
84323       {
84324         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84325       };
84326     }
84327   }
84328
84329 }
84330
84331
84332 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageFactory_GetNumberOfPages(void * jarg1) {
84333   unsigned int jresult ;
84334   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84335   unsigned int result;
84336
84337   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84338   {
84339     try {
84340       result = (unsigned int)(arg1)->GetNumberOfPages();
84341     } catch (std::out_of_range& e) {
84342       {
84343         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84344       };
84345     } catch (std::exception& e) {
84346       {
84347         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84348       };
84349     } catch (Dali::DaliException e) {
84350       {
84351         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84352       };
84353     } catch (...) {
84354       {
84355         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84356       };
84357     }
84358   }
84359
84360   jresult = result;
84361   return jresult;
84362 }
84363
84364
84365 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageFactory_NewPage(void * jarg1, unsigned int jarg2) {
84366   void * jresult ;
84367   Dali::Toolkit::PageFactory *arg1 = (Dali::Toolkit::PageFactory *) 0 ;
84368   unsigned int arg2 ;
84369   Dali::Texture result;
84370
84371   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84372   arg2 = (unsigned int)jarg2;
84373   {
84374     try {
84375       result = (arg1)->NewPage(arg2);
84376     } catch (std::out_of_range& e) {
84377       {
84378         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84379       };
84380     } catch (std::exception& e) {
84381       {
84382         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84383       };
84384     } catch (Dali::DaliException e) {
84385       {
84386         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84387       };
84388     } catch (...) {
84389       {
84390         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84391       };
84392     }
84393   }
84394
84395   jresult = new Dali::Texture((const Dali::Texture &)result);
84396   return jresult;
84397 }
84398
84399
84400 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_VIEW_PAGE_SIZE_get() {
84401   int jresult ;
84402   int result;
84403
84404   result = (int)Dali::Toolkit::PageTurnView::Property::VIEW_PAGE_SIZE;
84405   jresult = (int)result;
84406   return jresult;
84407 }
84408
84409
84410 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_CURRENT_PAGE_ID_get() {
84411   int jresult ;
84412   int result;
84413
84414   result = (int)Dali::Toolkit::PageTurnView::Property::CURRENT_PAGE_ID;
84415   jresult = (int)result;
84416   return jresult;
84417 }
84418
84419
84420 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PageTurnView_Property_SPINE_SHADOW_get() {
84421   int jresult ;
84422   int result;
84423
84424   result = (int)Dali::Toolkit::PageTurnView::Property::SPINE_SHADOW;
84425   jresult = (int)result;
84426   return jresult;
84427 }
84428
84429
84430 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView_Property() {
84431   void * jresult ;
84432   Dali::Toolkit::PageTurnView::Property *result = 0 ;
84433
84434   {
84435     try {
84436       result = (Dali::Toolkit::PageTurnView::Property *)new Dali::Toolkit::PageTurnView::Property();
84437     } catch (std::out_of_range& e) {
84438       {
84439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84440       };
84441     } catch (std::exception& e) {
84442       {
84443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84444       };
84445     } catch (Dali::DaliException e) {
84446       {
84447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84448       };
84449     } catch (...) {
84450       {
84451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84452       };
84453     }
84454   }
84455
84456   jresult = (void *)result;
84457   return jresult;
84458 }
84459
84460
84461 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView_Property(void * jarg1) {
84462   Dali::Toolkit::PageTurnView::Property *arg1 = (Dali::Toolkit::PageTurnView::Property *) 0 ;
84463
84464   arg1 = (Dali::Toolkit::PageTurnView::Property *)jarg1;
84465   {
84466     try {
84467       delete arg1;
84468     } catch (std::out_of_range& e) {
84469       {
84470         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84471       };
84472     } catch (std::exception& e) {
84473       {
84474         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84475       };
84476     } catch (Dali::DaliException e) {
84477       {
84478         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84479       };
84480     } catch (...) {
84481       {
84482         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84483       };
84484     }
84485   }
84486
84487 }
84488
84489
84490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_0() {
84491   void * jresult ;
84492   Dali::Toolkit::PageTurnView *result = 0 ;
84493
84494   {
84495     try {
84496       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView();
84497     } catch (std::out_of_range& e) {
84498       {
84499         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84500       };
84501     } catch (std::exception& e) {
84502       {
84503         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84504       };
84505     } catch (Dali::DaliException e) {
84506       {
84507         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84508       };
84509     } catch (...) {
84510       {
84511         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84512       };
84513     }
84514   }
84515
84516   jresult = (void *)result;
84517   return jresult;
84518 }
84519
84520
84521 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnView__SWIG_1(void * jarg1) {
84522   void * jresult ;
84523   Dali::Toolkit::PageTurnView *arg1 = 0 ;
84524   Dali::Toolkit::PageTurnView *result = 0 ;
84525
84526   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84527   if (!arg1) {
84528     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84529     return 0;
84530   }
84531   {
84532     try {
84533       result = (Dali::Toolkit::PageTurnView *)new Dali::Toolkit::PageTurnView((Dali::Toolkit::PageTurnView const &)*arg1);
84534     } catch (std::out_of_range& e) {
84535       {
84536         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84537       };
84538     } catch (std::exception& e) {
84539       {
84540         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84541       };
84542     } catch (Dali::DaliException e) {
84543       {
84544         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84545       };
84546     } catch (...) {
84547       {
84548         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84549       };
84550     }
84551   }
84552
84553   jresult = (void *)result;
84554   return jresult;
84555 }
84556
84557
84558 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_Assign(void * jarg1, void * jarg2) {
84559   void * jresult ;
84560   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84561   Dali::Toolkit::PageTurnView *arg2 = 0 ;
84562   Dali::Toolkit::PageTurnView *result = 0 ;
84563
84564   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84565   arg2 = (Dali::Toolkit::PageTurnView *)jarg2;
84566   if (!arg2) {
84567     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnView const & type is null", 0);
84568     return 0;
84569   }
84570   {
84571     try {
84572       result = (Dali::Toolkit::PageTurnView *) &(arg1)->operator =((Dali::Toolkit::PageTurnView const &)*arg2);
84573     } catch (std::out_of_range& e) {
84574       {
84575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84576       };
84577     } catch (std::exception& e) {
84578       {
84579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84580       };
84581     } catch (Dali::DaliException e) {
84582       {
84583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84584       };
84585     } catch (...) {
84586       {
84587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84588       };
84589     }
84590   }
84591
84592   jresult = (void *)result;
84593   return jresult;
84594 }
84595
84596
84597 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnView(void * jarg1) {
84598   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84599
84600   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84601   {
84602     try {
84603       delete arg1;
84604     } catch (std::out_of_range& e) {
84605       {
84606         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84607       };
84608     } catch (std::exception& e) {
84609       {
84610         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84611       };
84612     } catch (Dali::DaliException e) {
84613       {
84614         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84615       };
84616     } catch (...) {
84617       {
84618         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84619       };
84620     }
84621   }
84622
84623 }
84624
84625
84626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_DownCast(void * jarg1) {
84627   void * jresult ;
84628   Dali::BaseHandle arg1 ;
84629   Dali::BaseHandle *argp1 ;
84630   Dali::Toolkit::PageTurnView result;
84631
84632   argp1 = (Dali::BaseHandle *)jarg1;
84633   if (!argp1) {
84634     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84635     return 0;
84636   }
84637   arg1 = *argp1;
84638   {
84639     try {
84640       result = Dali::Toolkit::PageTurnView::DownCast(arg1);
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 = new Dali::Toolkit::PageTurnView((const Dali::Toolkit::PageTurnView &)result);
84661   return jresult;
84662 }
84663
84664
84665 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnStartedSignal(void * jarg1) {
84666   void * jresult ;
84667   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84668   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84669
84670   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84671   {
84672     try {
84673       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnStartedSignal();
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 = (void *)result;
84694   return jresult;
84695 }
84696
84697
84698 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PageTurnFinishedSignal(void * jarg1) {
84699   void * jresult ;
84700   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84701   Dali::Toolkit::PageTurnView::PageTurnSignal *result = 0 ;
84702
84703   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84704   {
84705     try {
84706       result = (Dali::Toolkit::PageTurnView::PageTurnSignal *) &(arg1)->PageTurnFinishedSignal();
84707     } catch (std::out_of_range& e) {
84708       {
84709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84710       };
84711     } catch (std::exception& e) {
84712       {
84713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84714       };
84715     } catch (Dali::DaliException e) {
84716       {
84717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84718       };
84719     } catch (...) {
84720       {
84721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84722       };
84723     }
84724   }
84725
84726   jresult = (void *)result;
84727   return jresult;
84728 }
84729
84730
84731 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanStartedSignal(void * jarg1) {
84732   void * jresult ;
84733   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84734   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84735
84736   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84737   {
84738     try {
84739       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanStartedSignal();
84740     } catch (std::out_of_range& e) {
84741       {
84742         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84743       };
84744     } catch (std::exception& e) {
84745       {
84746         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84747       };
84748     } catch (Dali::DaliException e) {
84749       {
84750         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84751       };
84752     } catch (...) {
84753       {
84754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84755       };
84756     }
84757   }
84758
84759   jresult = (void *)result;
84760   return jresult;
84761 }
84762
84763
84764 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnView_PagePanFinishedSignal(void * jarg1) {
84765   void * jresult ;
84766   Dali::Toolkit::PageTurnView *arg1 = (Dali::Toolkit::PageTurnView *) 0 ;
84767   Dali::Toolkit::PageTurnView::PagePanSignal *result = 0 ;
84768
84769   arg1 = (Dali::Toolkit::PageTurnView *)jarg1;
84770   {
84771     try {
84772       result = (Dali::Toolkit::PageTurnView::PagePanSignal *) &(arg1)->PagePanFinishedSignal();
84773     } catch (std::out_of_range& e) {
84774       {
84775         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84776       };
84777     } catch (std::exception& e) {
84778       {
84779         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84780       };
84781     } catch (Dali::DaliException e) {
84782       {
84783         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84784       };
84785     } catch (...) {
84786       {
84787         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84788       };
84789     }
84790   }
84791
84792   jresult = (void *)result;
84793   return jresult;
84794 }
84795
84796
84797 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_0() {
84798   void * jresult ;
84799   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84800
84801   {
84802     try {
84803       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView();
84804     } catch (std::out_of_range& e) {
84805       {
84806         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84807       };
84808     } catch (std::exception& e) {
84809       {
84810         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84811       };
84812     } catch (Dali::DaliException e) {
84813       {
84814         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84815       };
84816     } catch (...) {
84817       {
84818         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84819       };
84820     }
84821   }
84822
84823   jresult = (void *)result;
84824   return jresult;
84825 }
84826
84827
84828 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnLandscapeView__SWIG_1(void * jarg1) {
84829   void * jresult ;
84830   Dali::Toolkit::PageTurnLandscapeView *arg1 = 0 ;
84831   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84832
84833   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84834   if (!arg1) {
84835     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84836     return 0;
84837   }
84838   {
84839     try {
84840       result = (Dali::Toolkit::PageTurnLandscapeView *)new Dali::Toolkit::PageTurnLandscapeView((Dali::Toolkit::PageTurnLandscapeView const &)*arg1);
84841     } catch (std::out_of_range& e) {
84842       {
84843         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84844       };
84845     } catch (std::exception& e) {
84846       {
84847         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84848       };
84849     } catch (Dali::DaliException e) {
84850       {
84851         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84852       };
84853     } catch (...) {
84854       {
84855         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84856       };
84857     }
84858   }
84859
84860   jresult = (void *)result;
84861   return jresult;
84862 }
84863
84864
84865 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_Assign(void * jarg1, void * jarg2) {
84866   void * jresult ;
84867   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84868   Dali::Toolkit::PageTurnLandscapeView *arg2 = 0 ;
84869   Dali::Toolkit::PageTurnLandscapeView *result = 0 ;
84870
84871   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84872   arg2 = (Dali::Toolkit::PageTurnLandscapeView *)jarg2;
84873   if (!arg2) {
84874     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnLandscapeView const & type is null", 0);
84875     return 0;
84876   }
84877   {
84878     try {
84879       result = (Dali::Toolkit::PageTurnLandscapeView *) &(arg1)->operator =((Dali::Toolkit::PageTurnLandscapeView const &)*arg2);
84880     } catch (std::out_of_range& e) {
84881       {
84882         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84883       };
84884     } catch (std::exception& e) {
84885       {
84886         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84887       };
84888     } catch (Dali::DaliException e) {
84889       {
84890         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84891       };
84892     } catch (...) {
84893       {
84894         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84895       };
84896     }
84897   }
84898
84899   jresult = (void *)result;
84900   return jresult;
84901 }
84902
84903
84904 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnLandscapeView(void * jarg1) {
84905   Dali::Toolkit::PageTurnLandscapeView *arg1 = (Dali::Toolkit::PageTurnLandscapeView *) 0 ;
84906
84907   arg1 = (Dali::Toolkit::PageTurnLandscapeView *)jarg1;
84908   {
84909     try {
84910       delete arg1;
84911     } catch (std::out_of_range& e) {
84912       {
84913         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
84914       };
84915     } catch (std::exception& e) {
84916       {
84917         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
84918       };
84919     } catch (Dali::DaliException e) {
84920       {
84921         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
84922       };
84923     } catch (...) {
84924       {
84925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
84926       };
84927     }
84928   }
84929
84930 }
84931
84932
84933 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_New(void * jarg1, void * jarg2) {
84934   void * jresult ;
84935   Dali::Toolkit::PageFactory *arg1 = 0 ;
84936   Dali::Vector2 *arg2 = 0 ;
84937   Dali::Toolkit::PageTurnLandscapeView result;
84938
84939   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
84940   if (!arg1) {
84941     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
84942     return 0;
84943   }
84944   arg2 = (Dali::Vector2 *)jarg2;
84945   if (!arg2) {
84946     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
84947     return 0;
84948   }
84949   {
84950     try {
84951       result = Dali::Toolkit::PageTurnLandscapeView::New(*arg1,(Dali::Vector2 const &)*arg2);
84952     } catch (std::out_of_range& e) {
84953       {
84954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84955       };
84956     } catch (std::exception& e) {
84957       {
84958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84959       };
84960     } catch (Dali::DaliException e) {
84961       {
84962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
84963       };
84964     } catch (...) {
84965       {
84966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
84967       };
84968     }
84969   }
84970
84971   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
84972   return jresult;
84973 }
84974
84975
84976 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_DownCast(void * jarg1) {
84977   void * jresult ;
84978   Dali::BaseHandle arg1 ;
84979   Dali::BaseHandle *argp1 ;
84980   Dali::Toolkit::PageTurnLandscapeView result;
84981
84982   argp1 = (Dali::BaseHandle *)jarg1;
84983   if (!argp1) {
84984     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
84985     return 0;
84986   }
84987   arg1 = *argp1;
84988   {
84989     try {
84990       result = Dali::Toolkit::PageTurnLandscapeView::DownCast(arg1);
84991     } catch (std::out_of_range& e) {
84992       {
84993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
84994       };
84995     } catch (std::exception& e) {
84996       {
84997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
84998       };
84999     } catch (Dali::DaliException e) {
85000       {
85001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85002       };
85003     } catch (...) {
85004       {
85005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85006       };
85007     }
85008   }
85009
85010   jresult = new Dali::Toolkit::PageTurnLandscapeView((const Dali::Toolkit::PageTurnLandscapeView &)result);
85011   return jresult;
85012 }
85013
85014
85015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_0() {
85016   void * jresult ;
85017   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85018
85019   {
85020     try {
85021       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView();
85022     } catch (std::out_of_range& e) {
85023       {
85024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85025       };
85026     } catch (std::exception& e) {
85027       {
85028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85029       };
85030     } catch (Dali::DaliException e) {
85031       {
85032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85033       };
85034     } catch (...) {
85035       {
85036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85037       };
85038     }
85039   }
85040
85041   jresult = (void *)result;
85042   return jresult;
85043 }
85044
85045
85046 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnPortraitView__SWIG_1(void * jarg1) {
85047   void * jresult ;
85048   Dali::Toolkit::PageTurnPortraitView *arg1 = 0 ;
85049   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85050
85051   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85052   if (!arg1) {
85053     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85054     return 0;
85055   }
85056   {
85057     try {
85058       result = (Dali::Toolkit::PageTurnPortraitView *)new Dali::Toolkit::PageTurnPortraitView((Dali::Toolkit::PageTurnPortraitView const &)*arg1);
85059     } catch (std::out_of_range& e) {
85060       {
85061         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85062       };
85063     } catch (std::exception& e) {
85064       {
85065         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85066       };
85067     } catch (Dali::DaliException e) {
85068       {
85069         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85070       };
85071     } catch (...) {
85072       {
85073         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85074       };
85075     }
85076   }
85077
85078   jresult = (void *)result;
85079   return jresult;
85080 }
85081
85082
85083 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_Assign(void * jarg1, void * jarg2) {
85084   void * jresult ;
85085   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85086   Dali::Toolkit::PageTurnPortraitView *arg2 = 0 ;
85087   Dali::Toolkit::PageTurnPortraitView *result = 0 ;
85088
85089   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85090   arg2 = (Dali::Toolkit::PageTurnPortraitView *)jarg2;
85091   if (!arg2) {
85092     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageTurnPortraitView const & type is null", 0);
85093     return 0;
85094   }
85095   {
85096     try {
85097       result = (Dali::Toolkit::PageTurnPortraitView *) &(arg1)->operator =((Dali::Toolkit::PageTurnPortraitView const &)*arg2);
85098     } catch (std::out_of_range& e) {
85099       {
85100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85101       };
85102     } catch (std::exception& e) {
85103       {
85104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85105       };
85106     } catch (Dali::DaliException e) {
85107       {
85108         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85109       };
85110     } catch (...) {
85111       {
85112         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85113       };
85114     }
85115   }
85116
85117   jresult = (void *)result;
85118   return jresult;
85119 }
85120
85121
85122 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnPortraitView(void * jarg1) {
85123   Dali::Toolkit::PageTurnPortraitView *arg1 = (Dali::Toolkit::PageTurnPortraitView *) 0 ;
85124
85125   arg1 = (Dali::Toolkit::PageTurnPortraitView *)jarg1;
85126   {
85127     try {
85128       delete arg1;
85129     } catch (std::out_of_range& e) {
85130       {
85131         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85132       };
85133     } catch (std::exception& e) {
85134       {
85135         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85136       };
85137     } catch (Dali::DaliException e) {
85138       {
85139         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85140       };
85141     } catch (...) {
85142       {
85143         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85144       };
85145     }
85146   }
85147
85148 }
85149
85150
85151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_New(void * jarg1, void * jarg2) {
85152   void * jresult ;
85153   Dali::Toolkit::PageFactory *arg1 = 0 ;
85154   Dali::Vector2 *arg2 = 0 ;
85155   Dali::Toolkit::PageTurnPortraitView result;
85156
85157   arg1 = (Dali::Toolkit::PageFactory *)jarg1;
85158   if (!arg1) {
85159     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::PageFactory & type is null", 0);
85160     return 0;
85161   }
85162   arg2 = (Dali::Vector2 *)jarg2;
85163   if (!arg2) {
85164     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
85165     return 0;
85166   }
85167   {
85168     try {
85169       result = Dali::Toolkit::PageTurnPortraitView::New(*arg1,(Dali::Vector2 const &)*arg2);
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 = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85190   return jresult;
85191 }
85192
85193
85194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_DownCast(void * jarg1) {
85195   void * jresult ;
85196   Dali::BaseHandle arg1 ;
85197   Dali::BaseHandle *argp1 ;
85198   Dali::Toolkit::PageTurnPortraitView result;
85199
85200   argp1 = (Dali::BaseHandle *)jarg1;
85201   if (!argp1) {
85202     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85203     return 0;
85204   }
85205   arg1 = *argp1;
85206   {
85207     try {
85208       result = Dali::Toolkit::PageTurnPortraitView::DownCast(arg1);
85209     } catch (std::out_of_range& e) {
85210       {
85211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85212       };
85213     } catch (std::exception& e) {
85214       {
85215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85216       };
85217     } catch (Dali::DaliException e) {
85218       {
85219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85220       };
85221     } catch (...) {
85222       {
85223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85224       };
85225     }
85226   }
85227
85228   jresult = new Dali::Toolkit::PageTurnPortraitView((const Dali::Toolkit::PageTurnPortraitView &)result);
85229   return jresult;
85230 }
85231
85232
85233 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_STATE_VISUALS_get() {
85234   int jresult ;
85235   int result;
85236
85237   result = (int)Dali::Toolkit::ToggleButton::Property::STATE_VISUALS;
85238   jresult = (int)result;
85239   return jresult;
85240 }
85241
85242
85243 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_TOOLTIPS_get() {
85244   int jresult ;
85245   int result;
85246
85247   result = (int)Dali::Toolkit::ToggleButton::Property::TOOLTIPS;
85248   jresult = (int)result;
85249   return jresult;
85250 }
85251
85252
85253 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ToggleButton_Property_CURRENT_STATE_INDEX_get() {
85254   int jresult ;
85255   int result;
85256
85257   result = (int)Dali::Toolkit::ToggleButton::Property::CURRENT_STATE_INDEX;
85258   jresult = (int)result;
85259   return jresult;
85260 }
85261
85262
85263 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton_Property() {
85264   void * jresult ;
85265   Dali::Toolkit::ToggleButton::Property *result = 0 ;
85266
85267   {
85268     try {
85269       result = (Dali::Toolkit::ToggleButton::Property *)new Dali::Toolkit::ToggleButton::Property();
85270     } catch (std::out_of_range& e) {
85271       {
85272         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85273       };
85274     } catch (std::exception& e) {
85275       {
85276         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85277       };
85278     } catch (Dali::DaliException e) {
85279       {
85280         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85281       };
85282     } catch (...) {
85283       {
85284         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85285       };
85286     }
85287   }
85288
85289   jresult = (void *)result;
85290   return jresult;
85291 }
85292
85293
85294 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton_Property(void * jarg1) {
85295   Dali::Toolkit::ToggleButton::Property *arg1 = (Dali::Toolkit::ToggleButton::Property *) 0 ;
85296
85297   arg1 = (Dali::Toolkit::ToggleButton::Property *)jarg1;
85298   {
85299     try {
85300       delete arg1;
85301     } catch (std::out_of_range& e) {
85302       {
85303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85304       };
85305     } catch (std::exception& e) {
85306       {
85307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85308       };
85309     } catch (Dali::DaliException e) {
85310       {
85311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85312       };
85313     } catch (...) {
85314       {
85315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85316       };
85317     }
85318   }
85319
85320 }
85321
85322
85323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_0() {
85324   void * jresult ;
85325   Dali::Toolkit::ToggleButton *result = 0 ;
85326
85327   {
85328     try {
85329       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton();
85330     } catch (std::out_of_range& e) {
85331       {
85332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85333       };
85334     } catch (std::exception& e) {
85335       {
85336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85337       };
85338     } catch (Dali::DaliException e) {
85339       {
85340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85341       };
85342     } catch (...) {
85343       {
85344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85345       };
85346     }
85347   }
85348
85349   jresult = (void *)result;
85350   return jresult;
85351 }
85352
85353
85354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ToggleButton__SWIG_1(void * jarg1) {
85355   void * jresult ;
85356   Dali::Toolkit::ToggleButton *arg1 = 0 ;
85357   Dali::Toolkit::ToggleButton *result = 0 ;
85358
85359   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85360   if (!arg1) {
85361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85362     return 0;
85363   }
85364   {
85365     try {
85366       result = (Dali::Toolkit::ToggleButton *)new Dali::Toolkit::ToggleButton((Dali::Toolkit::ToggleButton const &)*arg1);
85367     } catch (std::out_of_range& e) {
85368       {
85369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85370       };
85371     } catch (std::exception& e) {
85372       {
85373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85374       };
85375     } catch (Dali::DaliException e) {
85376       {
85377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85378       };
85379     } catch (...) {
85380       {
85381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85382       };
85383     }
85384   }
85385
85386   jresult = (void *)result;
85387   return jresult;
85388 }
85389
85390
85391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_Assign(void * jarg1, void * jarg2) {
85392   void * jresult ;
85393   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85394   Dali::Toolkit::ToggleButton *arg2 = 0 ;
85395   Dali::Toolkit::ToggleButton *result = 0 ;
85396
85397   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85398   arg2 = (Dali::Toolkit::ToggleButton *)jarg2;
85399   if (!arg2) {
85400     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ToggleButton const & type is null", 0);
85401     return 0;
85402   }
85403   {
85404     try {
85405       result = (Dali::Toolkit::ToggleButton *) &(arg1)->operator =((Dali::Toolkit::ToggleButton const &)*arg2);
85406     } catch (std::out_of_range& e) {
85407       {
85408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85409       };
85410     } catch (std::exception& e) {
85411       {
85412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85413       };
85414     } catch (Dali::DaliException e) {
85415       {
85416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85417       };
85418     } catch (...) {
85419       {
85420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85421       };
85422     }
85423   }
85424
85425   jresult = (void *)result;
85426   return jresult;
85427 }
85428
85429
85430 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ToggleButton(void * jarg1) {
85431   Dali::Toolkit::ToggleButton *arg1 = (Dali::Toolkit::ToggleButton *) 0 ;
85432
85433   arg1 = (Dali::Toolkit::ToggleButton *)jarg1;
85434   {
85435     try {
85436       delete arg1;
85437     } catch (std::out_of_range& e) {
85438       {
85439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85440       };
85441     } catch (std::exception& e) {
85442       {
85443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85444       };
85445     } catch (Dali::DaliException e) {
85446       {
85447         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85448       };
85449     } catch (...) {
85450       {
85451         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85452       };
85453     }
85454   }
85455
85456 }
85457
85458
85459 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_New() {
85460   void * jresult ;
85461   Dali::Toolkit::ToggleButton result;
85462
85463   {
85464     try {
85465       result = Dali::Toolkit::ToggleButton::New();
85466     } catch (std::out_of_range& e) {
85467       {
85468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85469       };
85470     } catch (std::exception& e) {
85471       {
85472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85473       };
85474     } catch (Dali::DaliException e) {
85475       {
85476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85477       };
85478     } catch (...) {
85479       {
85480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85481       };
85482     }
85483   }
85484
85485   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85486   return jresult;
85487 }
85488
85489
85490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ToggleButton_DownCast(void * jarg1) {
85491   void * jresult ;
85492   Dali::BaseHandle arg1 ;
85493   Dali::BaseHandle *argp1 ;
85494   Dali::Toolkit::ToggleButton result;
85495
85496   argp1 = (Dali::BaseHandle *)jarg1;
85497   if (!argp1) {
85498     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
85499     return 0;
85500   }
85501   arg1 = *argp1;
85502   {
85503     try {
85504       result = Dali::Toolkit::ToggleButton::DownCast(arg1);
85505     } catch (std::out_of_range& e) {
85506       {
85507         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85508       };
85509     } catch (std::exception& e) {
85510       {
85511         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85512       };
85513     } catch (Dali::DaliException e) {
85514       {
85515         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85516       };
85517     } catch (...) {
85518       {
85519         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85520       };
85521     }
85522   }
85523
85524   jresult = new Dali::Toolkit::ToggleButton((const Dali::Toolkit::ToggleButton &)result);
85525   return jresult;
85526 }
85527
85528
85529 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_0() {
85530   void * jresult ;
85531   Dali::Toolkit::Visual::Base *result = 0 ;
85532
85533   {
85534     try {
85535       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base();
85536     } catch (std::out_of_range& e) {
85537       {
85538         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85539       };
85540     } catch (std::exception& e) {
85541       {
85542         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85543       };
85544     } catch (Dali::DaliException e) {
85545       {
85546         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85547       };
85548     } catch (...) {
85549       {
85550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85551       };
85552     }
85553   }
85554
85555   jresult = (void *)result;
85556   return jresult;
85557 }
85558
85559
85560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualBase(void * jarg1) {
85561   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85562
85563   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85564   {
85565     try {
85566       delete arg1;
85567     } catch (std::out_of_range& e) {
85568       {
85569         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85570       };
85571     } catch (std::exception& e) {
85572       {
85573         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85574       };
85575     } catch (Dali::DaliException e) {
85576       {
85577         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85578       };
85579     } catch (...) {
85580       {
85581         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85582       };
85583     }
85584   }
85585
85586 }
85587
85588
85589 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualBase__SWIG_1(void * jarg1) {
85590   void * jresult ;
85591   Dali::Toolkit::Visual::Base *arg1 = 0 ;
85592   Dali::Toolkit::Visual::Base *result = 0 ;
85593
85594   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85595   if (!arg1) {
85596     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85597     return 0;
85598   }
85599   {
85600     try {
85601       result = (Dali::Toolkit::Visual::Base *)new Dali::Toolkit::Visual::Base((Dali::Toolkit::Visual::Base const &)*arg1);
85602     } catch (std::out_of_range& e) {
85603       {
85604         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85605       };
85606     } catch (std::exception& e) {
85607       {
85608         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85609       };
85610     } catch (Dali::DaliException e) {
85611       {
85612         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85613       };
85614     } catch (...) {
85615       {
85616         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85617       };
85618     }
85619   }
85620
85621   jresult = (void *)result;
85622   return jresult;
85623 }
85624
85625
85626 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualBase_Assign(void * jarg1, void * jarg2) {
85627   void * jresult ;
85628   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85629   Dali::Toolkit::Visual::Base *arg2 = 0 ;
85630   Dali::Toolkit::Visual::Base *result = 0 ;
85631
85632   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85633   arg2 = (Dali::Toolkit::Visual::Base *)jarg2;
85634   if (!arg2) {
85635     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::Visual::Base const & type is null", 0);
85636     return 0;
85637   }
85638   {
85639     try {
85640       result = (Dali::Toolkit::Visual::Base *) &(arg1)->operator =((Dali::Toolkit::Visual::Base const &)*arg2);
85641     } catch (std::out_of_range& e) {
85642       {
85643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85644       };
85645     } catch (std::exception& e) {
85646       {
85647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85648       };
85649     } catch (Dali::DaliException e) {
85650       {
85651         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85652       };
85653     } catch (...) {
85654       {
85655         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85656       };
85657     }
85658   }
85659
85660   jresult = (void *)result;
85661   return jresult;
85662 }
85663
85664
85665 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetName(void * jarg1, char * jarg2) {
85666   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85667   std::string *arg2 = 0 ;
85668
85669   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85670   if (!jarg2) {
85671     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
85672     return ;
85673   }
85674   std::string arg2_str(jarg2);
85675   arg2 = &arg2_str;
85676   {
85677     try {
85678       (arg1)->SetName((std::string const &)*arg2);
85679     } catch (std::out_of_range& e) {
85680       {
85681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85682       };
85683     } catch (std::exception& e) {
85684       {
85685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85686       };
85687     } catch (Dali::DaliException e) {
85688       {
85689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85690       };
85691     } catch (...) {
85692       {
85693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85694       };
85695     }
85696   }
85697
85698
85699   //argout typemap for const std::string&
85700
85701 }
85702
85703
85704 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_VisualBase_GetName(void * jarg1) {
85705   char * jresult ;
85706   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85707   std::string *result = 0 ;
85708
85709   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85710   {
85711     try {
85712       result = (std::string *) &(arg1)->GetName();
85713     } catch (std::out_of_range& e) {
85714       {
85715         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85716       };
85717     } catch (std::exception& e) {
85718       {
85719         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85720       };
85721     } catch (Dali::DaliException e) {
85722       {
85723         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85724       };
85725     } catch (...) {
85726       {
85727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85728       };
85729     }
85730   }
85731
85732   jresult = SWIG_csharp_string_callback(result->c_str());
85733   return jresult;
85734 }
85735
85736
85737 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetTransformAndSize(void * jarg1, void * jarg2, void * jarg3) {
85738   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85739   Dali::Property::Map *arg2 = 0 ;
85740   Dali::Size arg3 ;
85741   Dali::Size *argp3 ;
85742
85743   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85744   arg2 = (Dali::Property::Map *)jarg2;
85745   if (!arg2) {
85746     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
85747     return ;
85748   }
85749   argp3 = (Dali::Size *)jarg3;
85750   if (!argp3) {
85751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Size", 0);
85752     return ;
85753   }
85754   arg3 = *argp3;
85755   {
85756     try {
85757       (arg1)->SetTransformAndSize((Dali::Property::Map const &)*arg2,arg3);
85758     } catch (std::out_of_range& e) {
85759       {
85760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85761       };
85762     } catch (std::exception& e) {
85763       {
85764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85765       };
85766     } catch (Dali::DaliException e) {
85767       {
85768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85769       };
85770     } catch (...) {
85771       {
85772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85773       };
85774     }
85775   }
85776
85777 }
85778
85779
85780 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetHeightForWidth(void * jarg1, float jarg2) {
85781   float jresult ;
85782   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85783   float arg2 ;
85784   float result;
85785
85786   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85787   arg2 = (float)jarg2;
85788   {
85789     try {
85790       result = (float)(arg1)->GetHeightForWidth(arg2);
85791     } catch (std::out_of_range& e) {
85792       {
85793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85794       };
85795     } catch (std::exception& e) {
85796       {
85797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85798       };
85799     } catch (Dali::DaliException e) {
85800       {
85801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85802       };
85803     } catch (...) {
85804       {
85805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85806       };
85807     }
85808   }
85809
85810   jresult = result;
85811   return jresult;
85812 }
85813
85814
85815 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_VisualBase_GetWidthForHeight(void * jarg1, float jarg2) {
85816   float jresult ;
85817   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85818   float arg2 ;
85819   float result;
85820
85821   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85822   arg2 = (float)jarg2;
85823   {
85824     try {
85825       result = (float)(arg1)->GetWidthForHeight(arg2);
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 = result;
85846   return jresult;
85847 }
85848
85849
85850 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_GetNaturalSize(void * jarg1, void * jarg2) {
85851   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85852   Dali::Vector2 *arg2 = 0 ;
85853
85854   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85855   arg2 = (Dali::Vector2 *)jarg2;
85856   if (!arg2) {
85857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 & type is null", 0);
85858     return ;
85859   }
85860   {
85861     try {
85862       (arg1)->GetNaturalSize(*arg2);
85863     } catch (std::out_of_range& e) {
85864       {
85865         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85866       };
85867     } catch (std::exception& e) {
85868       {
85869         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85870       };
85871     } catch (Dali::DaliException e) {
85872       {
85873         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85874       };
85875     } catch (...) {
85876       {
85877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85878       };
85879     }
85880   }
85881
85882 }
85883
85884
85885 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_SetDepthIndex(void * jarg1, int jarg2) {
85886   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85887   float arg2 ;
85888
85889   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85890   arg2 = (int)jarg2;
85891   {
85892     try {
85893       (arg1)->SetDepthIndex(arg2);
85894     } catch (std::out_of_range& e) {
85895       {
85896         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85897       };
85898     } catch (std::exception& e) {
85899       {
85900         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85901       };
85902     } catch (Dali::DaliException e) {
85903       {
85904         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85905       };
85906     } catch (...) {
85907       {
85908         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85909       };
85910     }
85911   }
85912
85913 }
85914
85915
85916 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_VisualBase_GetDepthIndex(void * jarg1) {
85917   int jresult ;
85918   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85919   int result;
85920
85921   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85922   {
85923     try {
85924       result = (float)((Dali::Toolkit::Visual::Base const *)arg1)->GetDepthIndex();
85925     } catch (std::out_of_range& e) {
85926       {
85927         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85928       };
85929     } catch (std::exception& e) {
85930       {
85931         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85932       };
85933     } catch (Dali::DaliException e) {
85934       {
85935         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
85936       };
85937     } catch (...) {
85938       {
85939         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
85940       };
85941     }
85942   }
85943
85944   jresult = result;
85945   return jresult;
85946 }
85947
85948
85949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VisualBase_CreatePropertyMap(void * jarg1, void * jarg2) {
85950   Dali::Toolkit::Visual::Base *arg1 = (Dali::Toolkit::Visual::Base *) 0 ;
85951   Dali::Property::Map *arg2 = 0 ;
85952
85953   arg1 = (Dali::Toolkit::Visual::Base *)jarg1;
85954   arg2 = (Dali::Property::Map *)jarg2;
85955   if (!arg2) {
85956     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map & type is null", 0);
85957     return ;
85958   }
85959   {
85960     try {
85961       ((Dali::Toolkit::Visual::Base const *)arg1)->CreatePropertyMap(*arg2);
85962     } catch (std::out_of_range& e) {
85963       {
85964         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
85965       };
85966     } catch (std::exception& e) {
85967       {
85968         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
85969       };
85970     } catch (Dali::DaliException e) {
85971       {
85972         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
85973       };
85974     } catch (...) {
85975       {
85976         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
85977       };
85978     }
85979   }
85980
85981 }
85982
85983
85984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Get() {
85985   void * jresult ;
85986   Dali::Toolkit::VisualFactory result;
85987
85988   {
85989     try {
85990       result = Dali::Toolkit::VisualFactory::Get();
85991     } catch (std::out_of_range& e) {
85992       {
85993         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
85994       };
85995     } catch (std::exception& e) {
85996       {
85997         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
85998       };
85999     } catch (Dali::DaliException e) {
86000       {
86001         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86002       };
86003     } catch (...) {
86004       {
86005         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86006       };
86007     }
86008   }
86009
86010   jresult = new Dali::Toolkit::VisualFactory((const Dali::Toolkit::VisualFactory &)result);
86011   return jresult;
86012 }
86013
86014
86015 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_0() {
86016   void * jresult ;
86017   Dali::Toolkit::VisualFactory *result = 0 ;
86018
86019   {
86020     try {
86021       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory();
86022     } catch (std::out_of_range& e) {
86023       {
86024         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86025       };
86026     } catch (std::exception& e) {
86027       {
86028         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86029       };
86030     } catch (Dali::DaliException e) {
86031       {
86032         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86033       };
86034     } catch (...) {
86035       {
86036         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86037       };
86038     }
86039   }
86040
86041   jresult = (void *)result;
86042   return jresult;
86043 }
86044
86045
86046 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VisualFactory(void * jarg1) {
86047   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86048
86049   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86050   {
86051     try {
86052       delete arg1;
86053     } catch (std::out_of_range& e) {
86054       {
86055         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86056       };
86057     } catch (std::exception& e) {
86058       {
86059         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86060       };
86061     } catch (Dali::DaliException e) {
86062       {
86063         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86064       };
86065     } catch (...) {
86066       {
86067         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86068       };
86069     }
86070   }
86071
86072 }
86073
86074
86075 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VisualFactory__SWIG_1(void * jarg1) {
86076   void * jresult ;
86077   Dali::Toolkit::VisualFactory *arg1 = 0 ;
86078   Dali::Toolkit::VisualFactory *result = 0 ;
86079
86080   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86081   if (!arg1) {
86082     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86083     return 0;
86084   }
86085   {
86086     try {
86087       result = (Dali::Toolkit::VisualFactory *)new Dali::Toolkit::VisualFactory((Dali::Toolkit::VisualFactory const &)*arg1);
86088     } catch (std::out_of_range& e) {
86089       {
86090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86091       };
86092     } catch (std::exception& e) {
86093       {
86094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86095       };
86096     } catch (Dali::DaliException e) {
86097       {
86098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86099       };
86100     } catch (...) {
86101       {
86102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86103       };
86104     }
86105   }
86106
86107   jresult = (void *)result;
86108   return jresult;
86109 }
86110
86111
86112 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_Assign(void * jarg1, void * jarg2) {
86113   void * jresult ;
86114   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86115   Dali::Toolkit::VisualFactory *arg2 = 0 ;
86116   Dali::Toolkit::VisualFactory *result = 0 ;
86117
86118   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86119   arg2 = (Dali::Toolkit::VisualFactory *)jarg2;
86120   if (!arg2) {
86121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VisualFactory const & type is null", 0);
86122     return 0;
86123   }
86124   {
86125     try {
86126       result = (Dali::Toolkit::VisualFactory *) &(arg1)->operator =((Dali::Toolkit::VisualFactory const &)*arg2);
86127     } catch (std::out_of_range& e) {
86128       {
86129         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86130       };
86131     } catch (std::exception& e) {
86132       {
86133         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86134       };
86135     } catch (Dali::DaliException e) {
86136       {
86137         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86138       };
86139     } catch (...) {
86140       {
86141         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86142       };
86143     }
86144   }
86145
86146   jresult = (void *)result;
86147   return jresult;
86148 }
86149
86150
86151 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_0(void * jarg1, void * jarg2) {
86152   void * jresult ;
86153   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86154   Dali::Property::Map *arg2 = 0 ;
86155   Dali::Toolkit::Visual::Base result;
86156
86157   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86158   arg2 = (Dali::Property::Map *)jarg2;
86159   if (!arg2) {
86160     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Property::Map const & type is null", 0);
86161     return 0;
86162   }
86163   {
86164     try {
86165       result = (arg1)->CreateVisual((Dali::Property::Map const &)*arg2);
86166     } catch (std::out_of_range& e) {
86167       {
86168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86169       };
86170     } catch (std::exception& e) {
86171       {
86172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86173       };
86174     } catch (Dali::DaliException e) {
86175       {
86176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86177       };
86178     } catch (...) {
86179       {
86180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86181       };
86182     }
86183   }
86184
86185   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86186   return jresult;
86187 }
86188
86189
86190 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_VisualFactory_CreateVisual__SWIG_2(void * jarg1, char * jarg2, void * jarg3) {
86191   void * jresult ;
86192   Dali::Toolkit::VisualFactory *arg1 = (Dali::Toolkit::VisualFactory *) 0 ;
86193   std::string *arg2 = 0 ;
86194   Dali::ImageDimensions arg3 ;
86195   Dali::ImageDimensions *argp3 ;
86196   Dali::Toolkit::Visual::Base result;
86197
86198   arg1 = (Dali::Toolkit::VisualFactory *)jarg1;
86199   if (!jarg2) {
86200     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86201     return 0;
86202   }
86203   std::string arg2_str(jarg2);
86204   arg2 = &arg2_str;
86205   argp3 = (Dali::ImageDimensions *)jarg3;
86206   if (!argp3) {
86207     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86208     return 0;
86209   }
86210   arg3 = *argp3;
86211   {
86212     try {
86213       result = (arg1)->CreateVisual((std::string const &)*arg2,arg3);
86214     } catch (std::out_of_range& e) {
86215       {
86216         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86217       };
86218     } catch (std::exception& e) {
86219       {
86220         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86221       };
86222     } catch (Dali::DaliException e) {
86223       {
86224         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86225       };
86226     } catch (...) {
86227       {
86228         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86229       };
86230     }
86231   }
86232
86233   jresult = new Dali::Toolkit::Visual::Base((const Dali::Toolkit::Visual::Base &)result);
86234
86235   //argout typemap for const std::string&
86236
86237   return jresult;
86238 }
86239
86240
86241 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_0() {
86242   void * jresult ;
86243   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86244
86245   {
86246     try {
86247       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader();
86248     } catch (std::out_of_range& e) {
86249       {
86250         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86251       };
86252     } catch (std::exception& e) {
86253       {
86254         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86255       };
86256     } catch (Dali::DaliException e) {
86257       {
86258         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86259       };
86260     } catch (...) {
86261       {
86262         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86263       };
86264     }
86265   }
86266
86267   jresult = (void *)result;
86268   return jresult;
86269 }
86270
86271
86272 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AsyncImageLoader(void * jarg1) {
86273   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86274
86275   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86276   {
86277     try {
86278       delete arg1;
86279     } catch (std::out_of_range& e) {
86280       {
86281         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86282       };
86283     } catch (std::exception& e) {
86284       {
86285         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86286       };
86287     } catch (Dali::DaliException e) {
86288       {
86289         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86290       };
86291     } catch (...) {
86292       {
86293         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86294       };
86295     }
86296   }
86297
86298 }
86299
86300
86301 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AsyncImageLoader__SWIG_1(void * jarg1) {
86302   void * jresult ;
86303   Dali::Toolkit::AsyncImageLoader *arg1 = 0 ;
86304   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86305
86306   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86307   if (!arg1) {
86308     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86309     return 0;
86310   }
86311   {
86312     try {
86313       result = (Dali::Toolkit::AsyncImageLoader *)new Dali::Toolkit::AsyncImageLoader((Dali::Toolkit::AsyncImageLoader const &)*arg1);
86314     } catch (std::out_of_range& e) {
86315       {
86316         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86317       };
86318     } catch (std::exception& e) {
86319       {
86320         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86321       };
86322     } catch (Dali::DaliException e) {
86323       {
86324         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86325       };
86326     } catch (...) {
86327       {
86328         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86329       };
86330     }
86331   }
86332
86333   jresult = (void *)result;
86334   return jresult;
86335 }
86336
86337
86338 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Assign(void * jarg1, void * jarg2) {
86339   void * jresult ;
86340   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86341   Dali::Toolkit::AsyncImageLoader *arg2 = 0 ;
86342   Dali::Toolkit::AsyncImageLoader *result = 0 ;
86343
86344   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86345   arg2 = (Dali::Toolkit::AsyncImageLoader *)jarg2;
86346   if (!arg2) {
86347     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AsyncImageLoader const & type is null", 0);
86348     return 0;
86349   }
86350   {
86351     try {
86352       result = (Dali::Toolkit::AsyncImageLoader *) &(arg1)->operator =((Dali::Toolkit::AsyncImageLoader const &)*arg2);
86353     } catch (std::out_of_range& e) {
86354       {
86355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86356       };
86357     } catch (std::exception& e) {
86358       {
86359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86360       };
86361     } catch (Dali::DaliException e) {
86362       {
86363         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86364       };
86365     } catch (...) {
86366       {
86367         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86368       };
86369     }
86370   }
86371
86372   jresult = (void *)result;
86373   return jresult;
86374 }
86375
86376
86377 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_New() {
86378   void * jresult ;
86379   Dali::Toolkit::AsyncImageLoader result;
86380
86381   {
86382     try {
86383       result = Dali::Toolkit::AsyncImageLoader::New();
86384     } catch (std::out_of_range& e) {
86385       {
86386         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86387       };
86388     } catch (std::exception& e) {
86389       {
86390         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86391       };
86392     } catch (Dali::DaliException e) {
86393       {
86394         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86395       };
86396     } catch (...) {
86397       {
86398         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86399       };
86400     }
86401   }
86402
86403   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86404   return jresult;
86405 }
86406
86407
86408 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_DownCast(void * jarg1) {
86409   void * jresult ;
86410   Dali::BaseHandle arg1 ;
86411   Dali::BaseHandle *argp1 ;
86412   Dali::Toolkit::AsyncImageLoader result;
86413
86414   argp1 = (Dali::BaseHandle *)jarg1;
86415   if (!argp1) {
86416     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
86417     return 0;
86418   }
86419   arg1 = *argp1;
86420   {
86421     try {
86422       result = Dali::Toolkit::AsyncImageLoader::DownCast(arg1);
86423     } catch (std::out_of_range& e) {
86424       {
86425         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86426       };
86427     } catch (std::exception& e) {
86428       {
86429         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86430       };
86431     } catch (Dali::DaliException e) {
86432       {
86433         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86434       };
86435     } catch (...) {
86436       {
86437         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86438       };
86439     }
86440   }
86441
86442   jresult = new Dali::Toolkit::AsyncImageLoader((const Dali::Toolkit::AsyncImageLoader &)result);
86443   return jresult;
86444 }
86445
86446
86447 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_0(void * jarg1, char * jarg2) {
86448   unsigned int jresult ;
86449   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86450   std::string *arg2 = 0 ;
86451   uint32_t result;
86452
86453   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86454   if (!jarg2) {
86455     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86456     return 0;
86457   }
86458   std::string arg2_str(jarg2);
86459   arg2 = &arg2_str;
86460   {
86461     try {
86462       result = (arg1)->Load((std::string const &)*arg2);
86463     } catch (std::out_of_range& e) {
86464       {
86465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86466       };
86467     } catch (std::exception& e) {
86468       {
86469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86470       };
86471     } catch (Dali::DaliException e) {
86472       {
86473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86474       };
86475     } catch (...) {
86476       {
86477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86478       };
86479     }
86480   }
86481
86482   jresult = result;
86483
86484   //argout typemap for const std::string&
86485
86486   return jresult;
86487 }
86488
86489
86490 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_1(void * jarg1, char * jarg2, void * jarg3) {
86491   unsigned int jresult ;
86492   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86493   std::string *arg2 = 0 ;
86494   Dali::ImageDimensions arg3 ;
86495   Dali::ImageDimensions *argp3 ;
86496   uint32_t result;
86497
86498   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86499   if (!jarg2) {
86500     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86501     return 0;
86502   }
86503   std::string arg2_str(jarg2);
86504   arg2 = &arg2_str;
86505   argp3 = (Dali::ImageDimensions *)jarg3;
86506   if (!argp3) {
86507     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86508     return 0;
86509   }
86510   arg3 = *argp3;
86511   {
86512     try {
86513       result = (arg1)->Load((std::string const &)*arg2,arg3);
86514     } catch (std::out_of_range& e) {
86515       {
86516         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86517       };
86518     } catch (std::exception& e) {
86519       {
86520         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86521       };
86522     } catch (Dali::DaliException e) {
86523       {
86524         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86525       };
86526     } catch (...) {
86527       {
86528         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86529       };
86530     }
86531   }
86532
86533   jresult = result;
86534
86535   //argout typemap for const std::string&
86536
86537   return jresult;
86538 }
86539
86540
86541 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Load__SWIG_2(void * jarg1, char * jarg2, void * jarg3, int jarg4, int jarg5, unsigned int jarg6) {
86542   unsigned int jresult ;
86543   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86544   std::string *arg2 = 0 ;
86545   Dali::ImageDimensions arg3 ;
86546   Dali::FittingMode::Type arg4 ;
86547   Dali::SamplingMode::Type arg5 ;
86548   bool arg6 ;
86549   Dali::ImageDimensions *argp3 ;
86550   uint32_t result;
86551
86552   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86553   if (!jarg2) {
86554     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86555     return 0;
86556   }
86557   std::string arg2_str(jarg2);
86558   arg2 = &arg2_str;
86559   argp3 = (Dali::ImageDimensions *)jarg3;
86560   if (!argp3) {
86561     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86562     return 0;
86563   }
86564   arg3 = *argp3;
86565   arg4 = (Dali::FittingMode::Type)jarg4;
86566   arg5 = (Dali::SamplingMode::Type)jarg5;
86567   arg6 = jarg6 ? true : false;
86568   {
86569     try {
86570       result = (arg1)->Load((std::string const &)*arg2,arg3,arg4,arg5,arg6);
86571     } catch (std::out_of_range& e) {
86572       {
86573         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86574       };
86575     } catch (std::exception& e) {
86576       {
86577         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86578       };
86579     } catch (Dali::DaliException e) {
86580       {
86581         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86582       };
86583     } catch (...) {
86584       {
86585         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86586       };
86587     }
86588   }
86589
86590   jresult = result;
86591
86592   //argout typemap for const std::string&
86593
86594   return jresult;
86595 }
86596
86597
86598 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AsyncImageLoader_Cancel(void * jarg1, unsigned int jarg2) {
86599   unsigned int jresult ;
86600   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86601   uint32_t arg2 ;
86602   bool result;
86603
86604   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86605   arg2 = (uint32_t)jarg2;
86606   {
86607     try {
86608       result = (bool)(arg1)->Cancel(arg2);
86609     } catch (std::out_of_range& e) {
86610       {
86611         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86612       };
86613     } catch (std::exception& e) {
86614       {
86615         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86616       };
86617     } catch (Dali::DaliException e) {
86618       {
86619         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86620       };
86621     } catch (...) {
86622       {
86623         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86624       };
86625     }
86626   }
86627
86628   jresult = result;
86629   return jresult;
86630 }
86631
86632
86633 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AsyncImageLoader_CancelAll(void * jarg1) {
86634   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86635
86636   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86637   {
86638     try {
86639       (arg1)->CancelAll();
86640     } catch (std::out_of_range& e) {
86641       {
86642         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86643       };
86644     } catch (std::exception& e) {
86645       {
86646         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86647       };
86648     } catch (Dali::DaliException e) {
86649       {
86650         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86651       };
86652     } catch (...) {
86653       {
86654         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86655       };
86656     }
86657   }
86658
86659 }
86660
86661
86662 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_ImageLoadedSignal(void * jarg1) {
86663   void * jresult ;
86664   Dali::Toolkit::AsyncImageLoader *arg1 = (Dali::Toolkit::AsyncImageLoader *) 0 ;
86665   Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *result = 0 ;
86666
86667   arg1 = (Dali::Toolkit::AsyncImageLoader *)jarg1;
86668   {
86669     try {
86670       result = (Dali::Toolkit::AsyncImageLoader::ImageLoadedSignalType *) &(arg1)->ImageLoadedSignal();
86671     } catch (std::out_of_range& e) {
86672       {
86673         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86674       };
86675     } catch (std::exception& e) {
86676       {
86677         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86678       };
86679     } catch (Dali::DaliException e) {
86680       {
86681         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86682       };
86683     } catch (...) {
86684       {
86685         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86686       };
86687     }
86688   }
86689
86690   jresult = (void *)result;
86691   return jresult;
86692 }
86693
86694
86695 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_0(char * jarg1) {
86696   void * jresult ;
86697   std::string *arg1 = 0 ;
86698   Dali::PixelData result;
86699
86700   if (!jarg1) {
86701     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86702     return 0;
86703   }
86704   std::string arg1_str(jarg1);
86705   arg1 = &arg1_str;
86706   {
86707     try {
86708       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1);
86709     } catch (std::out_of_range& e) {
86710       {
86711         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86712       };
86713     } catch (std::exception& e) {
86714       {
86715         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86716       };
86717     } catch (Dali::DaliException e) {
86718       {
86719         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86720       };
86721     } catch (...) {
86722       {
86723         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86724       };
86725     }
86726   }
86727
86728   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86729
86730   //argout typemap for const std::string&
86731
86732   return jresult;
86733 }
86734
86735
86736 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_1(char * jarg1, void * jarg2) {
86737   void * jresult ;
86738   std::string *arg1 = 0 ;
86739   Dali::ImageDimensions arg2 ;
86740   Dali::ImageDimensions *argp2 ;
86741   Dali::PixelData result;
86742
86743   if (!jarg1) {
86744     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86745     return 0;
86746   }
86747   std::string arg1_str(jarg1);
86748   arg1 = &arg1_str;
86749   argp2 = (Dali::ImageDimensions *)jarg2;
86750   if (!argp2) {
86751     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86752     return 0;
86753   }
86754   arg2 = *argp2;
86755   {
86756     try {
86757       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2);
86758     } catch (std::out_of_range& e) {
86759       {
86760         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86761       };
86762     } catch (std::exception& e) {
86763       {
86764         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86765       };
86766     } catch (Dali::DaliException e) {
86767       {
86768         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86769       };
86770     } catch (...) {
86771       {
86772         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86773       };
86774     }
86775   }
86776
86777   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86778
86779   //argout typemap for const std::string&
86780
86781   return jresult;
86782 }
86783
86784
86785 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
86786   void * jresult ;
86787   std::string *arg1 = 0 ;
86788   Dali::ImageDimensions arg2 ;
86789   Dali::FittingMode::Type arg3 ;
86790   Dali::SamplingMode::Type arg4 ;
86791   bool arg5 ;
86792   Dali::ImageDimensions *argp2 ;
86793   Dali::PixelData result;
86794
86795   if (!jarg1) {
86796     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
86797     return 0;
86798   }
86799   std::string arg1_str(jarg1);
86800   arg1 = &arg1_str;
86801   argp2 = (Dali::ImageDimensions *)jarg2;
86802   if (!argp2) {
86803     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
86804     return 0;
86805   }
86806   arg2 = *argp2;
86807   arg3 = (Dali::FittingMode::Type)jarg3;
86808   arg4 = (Dali::SamplingMode::Type)jarg4;
86809   arg5 = jarg5 ? true : false;
86810   {
86811     try {
86812       result = Dali::Toolkit::SyncImageLoader::Load((std::string const &)*arg1,arg2,arg3,arg4,arg5);
86813     } catch (std::out_of_range& e) {
86814       {
86815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86816       };
86817     } catch (std::exception& e) {
86818       {
86819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86820       };
86821     } catch (Dali::DaliException e) {
86822       {
86823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86824       };
86825     } catch (...) {
86826       {
86827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86828       };
86829     }
86830   }
86831
86832   jresult = new Dali::PixelData((const Dali::PixelData &)result);
86833
86834   //argout typemap for const std::string&
86835
86836   return jresult;
86837 }
86838
86839
86840 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_CustomAlgorithmInterface(void * jarg1) {
86841   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86842
86843   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86844   {
86845     try {
86846       delete arg1;
86847     } catch (std::out_of_range& e) {
86848       {
86849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86850       };
86851     } catch (std::exception& e) {
86852       {
86853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86854       };
86855     } catch (Dali::DaliException e) {
86856       {
86857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86858       };
86859     } catch (...) {
86860       {
86861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86862       };
86863     }
86864   }
86865
86866 }
86867
86868
86869 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_GetNextFocusableActor(void * jarg1, void * jarg2, void * jarg3, int jarg4) {
86870   void * jresult ;
86871   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *) 0 ;
86872   Dali::Actor arg2 ;
86873   Dali::Actor arg3 ;
86874   Dali::Toolkit::Control::KeyboardFocus::Direction arg4 ;
86875   Dali::Actor *argp2 ;
86876   Dali::Actor *argp3 ;
86877   Dali::Actor result;
86878
86879   arg1 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg1;
86880   argp2 = (Dali::Actor *)jarg2;
86881   if (!argp2) {
86882     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86883     return 0;
86884   }
86885   arg2 = *argp2;
86886   argp3 = (Dali::Actor *)jarg3;
86887   if (!argp3) {
86888     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
86889     return 0;
86890   }
86891   arg3 = *argp3;
86892   arg4 = (Dali::Toolkit::Control::KeyboardFocus::Direction)jarg4;
86893   {
86894     try {
86895       result = (arg1)->GetNextFocusableActor(arg2,arg3,arg4);
86896     } catch (std::out_of_range& e) {
86897       {
86898         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86899       };
86900     } catch (std::exception& e) {
86901       {
86902         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86903       };
86904     } catch (Dali::DaliException e) {
86905       {
86906         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86907       };
86908     } catch (...) {
86909       {
86910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86911       };
86912     }
86913   }
86914
86915   jresult = new Dali::Actor((const Dali::Actor &)result);
86916   return jresult;
86917 }
86918
86919
86920 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_CustomAlgorithmInterface() {
86921   void * jresult ;
86922   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *result = 0 ;
86923
86924   {
86925     try {
86926       result = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)new SwigDirector_CustomAlgorithmInterface();
86927     } catch (std::out_of_range& e) {
86928       {
86929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
86930       };
86931     } catch (std::exception& e) {
86932       {
86933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
86934       };
86935     } catch (Dali::DaliException e) {
86936       {
86937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
86938       };
86939     } catch (...) {
86940       {
86941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
86942       };
86943     }
86944   }
86945
86946   jresult = (void *)result;
86947   return jresult;
86948 }
86949
86950
86951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_CustomAlgorithmInterface_director_connect(void *objarg, SwigDirector_CustomAlgorithmInterface::SWIG_Callback0_t callback0) {
86952   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *obj = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)objarg;
86953   SwigDirector_CustomAlgorithmInterface *director = dynamic_cast<SwigDirector_CustomAlgorithmInterface *>(obj);
86954   if (director) {
86955     director->swig_connect_director(callback0);
86956   }
86957 }
86958
86959
86960 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SetCustomAlgorithm(void * jarg1, void * jarg2) {
86961   KeyboardFocusManager arg1 ;
86962   Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *arg2 = 0 ;
86963   KeyboardFocusManager *argp1 ;
86964
86965   argp1 = (KeyboardFocusManager *)jarg1;
86966   if (!argp1) {
86967     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null KeyboardFocusManager", 0);
86968     return ;
86969   }
86970   arg1 = *argp1;
86971   arg2 = (Dali::Toolkit::DevelKeyboardFocusManager::CustomAlgorithmInterface *)jarg2;
86972   //Null checking of arg2 is removed. arg2's null set means resetting so it can be a null value.
86973   {
86974     try {
86975       Dali::Toolkit::DevelKeyboardFocusManager::SetCustomAlgorithm(arg1,*arg2);
86976     } catch (std::out_of_range& e) {
86977       {
86978         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
86979       };
86980     } catch (std::exception& e) {
86981       {
86982         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
86983       };
86984     } catch (Dali::DaliException e) {
86985       {
86986         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
86987       };
86988     } catch (...) {
86989       {
86990         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
86991       };
86992     }
86993   }
86994
86995 }
86996
86997
86998 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Clear(void * jarg1) {
86999   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87000
87001   arg1 = (std::vector< unsigned int > *)jarg1;
87002   {
87003     try {
87004       (arg1)->clear();
87005     } catch (std::out_of_range& e) {
87006       {
87007         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87008       };
87009     } catch (std::exception& e) {
87010       {
87011         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87012       };
87013     } catch (Dali::DaliException e) {
87014       {
87015         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87016       };
87017     } catch (...) {
87018       {
87019         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87020       };
87021     }
87022   }
87023
87024 }
87025
87026
87027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Add(void * jarg1, unsigned int jarg2) {
87028   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87029   unsigned int *arg2 = 0 ;
87030   unsigned int temp2 ;
87031
87032   arg1 = (std::vector< unsigned int > *)jarg1;
87033   temp2 = (unsigned int)jarg2;
87034   arg2 = &temp2;
87035   {
87036     try {
87037       (arg1)->push_back((unsigned int const &)*arg2);
87038     } catch (std::out_of_range& e) {
87039       {
87040         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87041       };
87042     } catch (std::exception& e) {
87043       {
87044         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87045       };
87046     } catch (Dali::DaliException e) {
87047       {
87048         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87049       };
87050     } catch (...) {
87051       {
87052         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87053       };
87054     }
87055   }
87056
87057 }
87058
87059
87060 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_size(void * jarg1) {
87061   unsigned long jresult ;
87062   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87063   std::vector< unsigned int >::size_type result;
87064
87065   arg1 = (std::vector< unsigned int > *)jarg1;
87066   {
87067     try {
87068       result = ((std::vector< unsigned int > const *)arg1)->size();
87069     } catch (std::out_of_range& e) {
87070       {
87071         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87072       };
87073     } catch (std::exception& e) {
87074       {
87075         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87076       };
87077     } catch (Dali::DaliException e) {
87078       {
87079         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87080       };
87081     } catch (...) {
87082       {
87083         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87084       };
87085     }
87086   }
87087
87088   jresult = (unsigned long)result;
87089   return jresult;
87090 }
87091
87092
87093 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemIdContainer_capacity(void * jarg1) {
87094   unsigned long jresult ;
87095   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87096   std::vector< unsigned int >::size_type result;
87097
87098   arg1 = (std::vector< unsigned int > *)jarg1;
87099   {
87100     try {
87101       result = ((std::vector< unsigned int > const *)arg1)->capacity();
87102     } catch (std::out_of_range& e) {
87103       {
87104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87105       };
87106     } catch (std::exception& e) {
87107       {
87108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87109       };
87110     } catch (Dali::DaliException e) {
87111       {
87112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87113       };
87114     } catch (...) {
87115       {
87116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87117       };
87118     }
87119   }
87120
87121   jresult = (unsigned long)result;
87122   return jresult;
87123 }
87124
87125
87126 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_reserve(void * jarg1, unsigned long jarg2) {
87127   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87128   std::vector< unsigned int >::size_type arg2 ;
87129
87130   arg1 = (std::vector< unsigned int > *)jarg1;
87131   arg2 = (std::vector< unsigned int >::size_type)jarg2;
87132   {
87133     try {
87134       (arg1)->reserve(arg2);
87135     } catch (std::out_of_range& e) {
87136       {
87137         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87138       };
87139     } catch (std::exception& e) {
87140       {
87141         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87142       };
87143     } catch (Dali::DaliException e) {
87144       {
87145         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87146       };
87147     } catch (...) {
87148       {
87149         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87150       };
87151     }
87152   }
87153
87154 }
87155
87156
87157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_0() {
87158   void * jresult ;
87159   std::vector< unsigned int > *result = 0 ;
87160
87161   {
87162     try {
87163       result = (std::vector< unsigned int > *)new std::vector< unsigned int >();
87164     } catch (std::out_of_range& e) {
87165       {
87166         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87167       };
87168     } catch (std::exception& e) {
87169       {
87170         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87171       };
87172     } catch (Dali::DaliException e) {
87173       {
87174         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87175       };
87176     } catch (...) {
87177       {
87178         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87179       };
87180     }
87181   }
87182
87183   jresult = (void *)result;
87184   return jresult;
87185 }
87186
87187
87188 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_1(void * jarg1) {
87189   void * jresult ;
87190   std::vector< unsigned int > *arg1 = 0 ;
87191   std::vector< unsigned int > *result = 0 ;
87192
87193   arg1 = (std::vector< unsigned int > *)jarg1;
87194   if (!arg1) {
87195     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87196     return 0;
87197   }
87198   {
87199     try {
87200       result = (std::vector< unsigned int > *)new std::vector< unsigned int >((std::vector< unsigned int > const &)*arg1);
87201     } catch (std::out_of_range& e) {
87202       {
87203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87204       };
87205     } catch (std::exception& e) {
87206       {
87207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87208       };
87209     } catch (Dali::DaliException e) {
87210       {
87211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87212       };
87213     } catch (...) {
87214       {
87215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87216       };
87217     }
87218   }
87219
87220   jresult = (void *)result;
87221   return jresult;
87222 }
87223
87224
87225 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemIdContainer__SWIG_2(int jarg1) {
87226   void * jresult ;
87227   int arg1 ;
87228   std::vector< unsigned int > *result = 0 ;
87229
87230   arg1 = (int)jarg1;
87231   {
87232     try {
87233       try {
87234         result = (std::vector< unsigned int > *)new_std_vector_Sl_unsigned_SS_int_Sg___SWIG_2(arg1);
87235       }
87236       catch(std::out_of_range &_e) {
87237         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87238         return 0;
87239       }
87240
87241     } catch (std::out_of_range& e) {
87242       {
87243         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87244       };
87245     } catch (std::exception& e) {
87246       {
87247         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87248       };
87249     } catch (Dali::DaliException e) {
87250       {
87251         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87252       };
87253     } catch (...) {
87254       {
87255         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87256       };
87257     }
87258   }
87259
87260   jresult = (void *)result;
87261   return jresult;
87262 }
87263
87264
87265 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitemcopy(void * jarg1, int jarg2) {
87266   unsigned int jresult ;
87267   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87268   int arg2 ;
87269   unsigned int result;
87270
87271   arg1 = (std::vector< unsigned int > *)jarg1;
87272   arg2 = (int)jarg2;
87273   {
87274     try {
87275       try {
87276         result = (unsigned int)std_vector_Sl_unsigned_SS_int_Sg__getitemcopy(arg1,arg2);
87277       }
87278       catch(std::out_of_range &_e) {
87279         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87280         return 0;
87281       }
87282
87283     } catch (std::out_of_range& e) {
87284       {
87285         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87286       };
87287     } catch (std::exception& e) {
87288       {
87289         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87290       };
87291     } catch (Dali::DaliException e) {
87292       {
87293         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87294       };
87295     } catch (...) {
87296       {
87297         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87298       };
87299     }
87300   }
87301
87302   jresult = result;
87303   return jresult;
87304 }
87305
87306
87307 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_getitem(void * jarg1, int jarg2) {
87308   unsigned int jresult ;
87309   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87310   int arg2 ;
87311   unsigned int *result = 0 ;
87312
87313   arg1 = (std::vector< unsigned int > *)jarg1;
87314   arg2 = (int)jarg2;
87315   {
87316     try {
87317       try {
87318         result = (unsigned int *) &std_vector_Sl_unsigned_SS_int_Sg__getitem(arg1,arg2);
87319       }
87320       catch(std::out_of_range &_e) {
87321         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87322         return 0;
87323       }
87324
87325     } catch (std::out_of_range& e) {
87326       {
87327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87328       };
87329     } catch (std::exception& e) {
87330       {
87331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87332       };
87333     } catch (Dali::DaliException e) {
87334       {
87335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87336       };
87337     } catch (...) {
87338       {
87339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87340       };
87341     }
87342   }
87343
87344   jresult = *result;
87345   return jresult;
87346 }
87347
87348
87349 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_setitem(void * jarg1, int jarg2, unsigned int jarg3) {
87350   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87351   int arg2 ;
87352   unsigned int *arg3 = 0 ;
87353   unsigned int temp3 ;
87354
87355   arg1 = (std::vector< unsigned int > *)jarg1;
87356   arg2 = (int)jarg2;
87357   temp3 = (unsigned int)jarg3;
87358   arg3 = &temp3;
87359   {
87360     try {
87361       try {
87362         std_vector_Sl_unsigned_SS_int_Sg__setitem(arg1,arg2,(unsigned int const &)*arg3);
87363       }
87364       catch(std::out_of_range &_e) {
87365         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87366         return ;
87367       }
87368
87369     } catch (std::out_of_range& e) {
87370       {
87371         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87372       };
87373     } catch (std::exception& e) {
87374       {
87375         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87376       };
87377     } catch (Dali::DaliException e) {
87378       {
87379         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87380       };
87381     } catch (...) {
87382       {
87383         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87384       };
87385     }
87386   }
87387
87388 }
87389
87390
87391 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_AddRange(void * jarg1, void * jarg2) {
87392   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87393   std::vector< unsigned int > *arg2 = 0 ;
87394
87395   arg1 = (std::vector< unsigned int > *)jarg1;
87396   arg2 = (std::vector< unsigned int > *)jarg2;
87397   if (!arg2) {
87398     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87399     return ;
87400   }
87401   {
87402     try {
87403       std_vector_Sl_unsigned_SS_int_Sg__AddRange(arg1,(std::vector< unsigned int > const &)*arg2);
87404     } catch (std::out_of_range& e) {
87405       {
87406         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87407       };
87408     } catch (std::exception& e) {
87409       {
87410         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87411       };
87412     } catch (Dali::DaliException e) {
87413       {
87414         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87415       };
87416     } catch (...) {
87417       {
87418         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87419       };
87420     }
87421   }
87422
87423 }
87424
87425
87426 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
87427   void * jresult ;
87428   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87429   int arg2 ;
87430   int arg3 ;
87431   std::vector< unsigned int > *result = 0 ;
87432
87433   arg1 = (std::vector< unsigned int > *)jarg1;
87434   arg2 = (int)jarg2;
87435   arg3 = (int)jarg3;
87436   {
87437     try {
87438       try {
87439         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__GetRange(arg1,arg2,arg3);
87440       }
87441       catch(std::out_of_range &_e) {
87442         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87443         return 0;
87444       }
87445       catch(std::invalid_argument &_e) {
87446         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87447         return 0;
87448       }
87449
87450     } catch (std::out_of_range& e) {
87451       {
87452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87453       };
87454     } catch (std::exception& e) {
87455       {
87456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87457       };
87458     } catch (Dali::DaliException e) {
87459       {
87460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87461       };
87462     } catch (...) {
87463       {
87464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87465       };
87466     }
87467   }
87468
87469   jresult = (void *)result;
87470   return jresult;
87471 }
87472
87473
87474 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Insert(void * jarg1, int jarg2, unsigned int jarg3) {
87475   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87476   int arg2 ;
87477   unsigned int *arg3 = 0 ;
87478   unsigned int temp3 ;
87479
87480   arg1 = (std::vector< unsigned int > *)jarg1;
87481   arg2 = (int)jarg2;
87482   temp3 = (unsigned int)jarg3;
87483   arg3 = &temp3;
87484   {
87485     try {
87486       try {
87487         std_vector_Sl_unsigned_SS_int_Sg__Insert(arg1,arg2,(unsigned int const &)*arg3);
87488       }
87489       catch(std::out_of_range &_e) {
87490         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87491         return ;
87492       }
87493
87494     } catch (std::out_of_range& e) {
87495       {
87496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87497       };
87498     } catch (std::exception& e) {
87499       {
87500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87501       };
87502     } catch (Dali::DaliException e) {
87503       {
87504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87505       };
87506     } catch (...) {
87507       {
87508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87509       };
87510     }
87511   }
87512
87513 }
87514
87515
87516 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
87517   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87518   int arg2 ;
87519   std::vector< unsigned int > *arg3 = 0 ;
87520
87521   arg1 = (std::vector< unsigned int > *)jarg1;
87522   arg2 = (int)jarg2;
87523   arg3 = (std::vector< unsigned int > *)jarg3;
87524   if (!arg3) {
87525     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87526     return ;
87527   }
87528   {
87529     try {
87530       try {
87531         std_vector_Sl_unsigned_SS_int_Sg__InsertRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87532       }
87533       catch(std::out_of_range &_e) {
87534         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87535         return ;
87536       }
87537
87538     } catch (std::out_of_range& e) {
87539       {
87540         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87541       };
87542     } catch (std::exception& e) {
87543       {
87544         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87545       };
87546     } catch (Dali::DaliException e) {
87547       {
87548         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87549       };
87550     } catch (...) {
87551       {
87552         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87553       };
87554     }
87555   }
87556
87557 }
87558
87559
87560 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveAt(void * jarg1, int jarg2) {
87561   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87562   int arg2 ;
87563
87564   arg1 = (std::vector< unsigned int > *)jarg1;
87565   arg2 = (int)jarg2;
87566   {
87567     try {
87568       try {
87569         std_vector_Sl_unsigned_SS_int_Sg__RemoveAt(arg1,arg2);
87570       }
87571       catch(std::out_of_range &_e) {
87572         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87573         return ;
87574       }
87575
87576     } catch (std::out_of_range& e) {
87577       {
87578         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87579       };
87580     } catch (std::exception& e) {
87581       {
87582         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87583       };
87584     } catch (Dali::DaliException e) {
87585       {
87586         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87587       };
87588     } catch (...) {
87589       {
87590         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87591       };
87592     }
87593   }
87594
87595 }
87596
87597
87598 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
87599   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87600   int arg2 ;
87601   int arg3 ;
87602
87603   arg1 = (std::vector< unsigned int > *)jarg1;
87604   arg2 = (int)jarg2;
87605   arg3 = (int)jarg3;
87606   {
87607     try {
87608       try {
87609         std_vector_Sl_unsigned_SS_int_Sg__RemoveRange(arg1,arg2,arg3);
87610       }
87611       catch(std::out_of_range &_e) {
87612         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87613         return ;
87614       }
87615       catch(std::invalid_argument &_e) {
87616         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87617         return ;
87618       }
87619
87620     } catch (std::out_of_range& e) {
87621       {
87622         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87623       };
87624     } catch (std::exception& e) {
87625       {
87626         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87627       };
87628     } catch (Dali::DaliException e) {
87629       {
87630         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87631       };
87632     } catch (...) {
87633       {
87634         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87635       };
87636     }
87637   }
87638
87639 }
87640
87641
87642 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemIdContainer_Repeat(unsigned int jarg1, int jarg2) {
87643   void * jresult ;
87644   unsigned int *arg1 = 0 ;
87645   int arg2 ;
87646   unsigned int temp1 ;
87647   std::vector< unsigned int > *result = 0 ;
87648
87649   temp1 = (unsigned int)jarg1;
87650   arg1 = &temp1;
87651   arg2 = (int)jarg2;
87652   {
87653     try {
87654       try {
87655         result = (std::vector< unsigned int > *)std_vector_Sl_unsigned_SS_int_Sg__Repeat((unsigned int const &)*arg1,arg2);
87656       }
87657       catch(std::out_of_range &_e) {
87658         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87659         return 0;
87660       }
87661
87662     } catch (std::out_of_range& e) {
87663       {
87664         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87665       };
87666     } catch (std::exception& e) {
87667       {
87668         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87669       };
87670     } catch (Dali::DaliException e) {
87671       {
87672         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87673       };
87674     } catch (...) {
87675       {
87676         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87677       };
87678     }
87679   }
87680
87681   jresult = (void *)result;
87682   return jresult;
87683 }
87684
87685
87686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_0(void * jarg1) {
87687   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87688
87689   arg1 = (std::vector< unsigned int > *)jarg1;
87690   {
87691     try {
87692       std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_0(arg1);
87693     } catch (std::out_of_range& e) {
87694       {
87695         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87696       };
87697     } catch (std::exception& e) {
87698       {
87699         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87700       };
87701     } catch (Dali::DaliException e) {
87702       {
87703         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87704       };
87705     } catch (...) {
87706       {
87707         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87708       };
87709     }
87710   }
87711
87712 }
87713
87714
87715 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
87716   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87717   int arg2 ;
87718   int arg3 ;
87719
87720   arg1 = (std::vector< unsigned int > *)jarg1;
87721   arg2 = (int)jarg2;
87722   arg3 = (int)jarg3;
87723   {
87724     try {
87725       try {
87726         std_vector_Sl_unsigned_SS_int_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
87727       }
87728       catch(std::out_of_range &_e) {
87729         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87730         return ;
87731       }
87732       catch(std::invalid_argument &_e) {
87733         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
87734         return ;
87735       }
87736
87737     } catch (std::out_of_range& e) {
87738       {
87739         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87740       };
87741     } catch (std::exception& e) {
87742       {
87743         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87744       };
87745     } catch (Dali::DaliException e) {
87746       {
87747         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87748       };
87749     } catch (...) {
87750       {
87751         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87752       };
87753     }
87754   }
87755
87756 }
87757
87758
87759 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemIdContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
87760   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87761   int arg2 ;
87762   std::vector< unsigned int > *arg3 = 0 ;
87763
87764   arg1 = (std::vector< unsigned int > *)jarg1;
87765   arg2 = (int)jarg2;
87766   arg3 = (std::vector< unsigned int > *)jarg3;
87767   if (!arg3) {
87768     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< unsigned int > const & type is null", 0);
87769     return ;
87770   }
87771   {
87772     try {
87773       try {
87774         std_vector_Sl_unsigned_SS_int_Sg__SetRange(arg1,arg2,(std::vector< unsigned int > const &)*arg3);
87775       }
87776       catch(std::out_of_range &_e) {
87777         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
87778         return ;
87779       }
87780
87781     } catch (std::out_of_range& e) {
87782       {
87783         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87784       };
87785     } catch (std::exception& e) {
87786       {
87787         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87788       };
87789     } catch (Dali::DaliException e) {
87790       {
87791         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87792       };
87793     } catch (...) {
87794       {
87795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87796       };
87797     }
87798   }
87799
87800 }
87801
87802
87803 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Contains(void * jarg1, unsigned int jarg2) {
87804   unsigned int jresult ;
87805   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87806   unsigned int *arg2 = 0 ;
87807   unsigned int temp2 ;
87808   bool result;
87809
87810   arg1 = (std::vector< unsigned int > *)jarg1;
87811   temp2 = (unsigned int)jarg2;
87812   arg2 = &temp2;
87813   {
87814     try {
87815       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Contains(arg1,(unsigned int const &)*arg2);
87816     } catch (std::out_of_range& e) {
87817       {
87818         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87819       };
87820     } catch (std::exception& e) {
87821       {
87822         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87823       };
87824     } catch (Dali::DaliException e) {
87825       {
87826         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87827       };
87828     } catch (...) {
87829       {
87830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87831       };
87832     }
87833   }
87834
87835   jresult = result;
87836   return jresult;
87837 }
87838
87839
87840 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_IndexOf(void * jarg1, unsigned int jarg2) {
87841   int jresult ;
87842   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87843   unsigned int *arg2 = 0 ;
87844   unsigned int temp2 ;
87845   int result;
87846
87847   arg1 = (std::vector< unsigned int > *)jarg1;
87848   temp2 = (unsigned int)jarg2;
87849   arg2 = &temp2;
87850   {
87851     try {
87852       result = (int)std_vector_Sl_unsigned_SS_int_Sg__IndexOf(arg1,(unsigned int const &)*arg2);
87853     } catch (std::out_of_range& e) {
87854       {
87855         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87856       };
87857     } catch (std::exception& e) {
87858       {
87859         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87860       };
87861     } catch (Dali::DaliException e) {
87862       {
87863         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87864       };
87865     } catch (...) {
87866       {
87867         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87868       };
87869     }
87870   }
87871
87872   jresult = result;
87873   return jresult;
87874 }
87875
87876
87877 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_ItemIdContainer_LastIndexOf(void * jarg1, unsigned int jarg2) {
87878   int jresult ;
87879   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87880   unsigned int *arg2 = 0 ;
87881   unsigned int temp2 ;
87882   int result;
87883
87884   arg1 = (std::vector< unsigned int > *)jarg1;
87885   temp2 = (unsigned int)jarg2;
87886   arg2 = &temp2;
87887   {
87888     try {
87889       result = (int)std_vector_Sl_unsigned_SS_int_Sg__LastIndexOf(arg1,(unsigned int const &)*arg2);
87890     } catch (std::out_of_range& e) {
87891       {
87892         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87893       };
87894     } catch (std::exception& e) {
87895       {
87896         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87897       };
87898     } catch (Dali::DaliException e) {
87899       {
87900         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87901       };
87902     } catch (...) {
87903       {
87904         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87905       };
87906     }
87907   }
87908
87909   jresult = result;
87910   return jresult;
87911 }
87912
87913
87914 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ItemIdContainer_Remove(void * jarg1, unsigned int jarg2) {
87915   unsigned int jresult ;
87916   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87917   unsigned int *arg2 = 0 ;
87918   unsigned int temp2 ;
87919   bool result;
87920
87921   arg1 = (std::vector< unsigned int > *)jarg1;
87922   temp2 = (unsigned int)jarg2;
87923   arg2 = &temp2;
87924   {
87925     try {
87926       result = (bool)std_vector_Sl_unsigned_SS_int_Sg__Remove(arg1,(unsigned int const &)*arg2);
87927     } catch (std::out_of_range& e) {
87928       {
87929         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87930       };
87931     } catch (std::exception& e) {
87932       {
87933         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87934       };
87935     } catch (Dali::DaliException e) {
87936       {
87937         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87938       };
87939     } catch (...) {
87940       {
87941         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
87942       };
87943     }
87944   }
87945
87946   jresult = result;
87947   return jresult;
87948 }
87949
87950
87951 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemIdContainer(void * jarg1) {
87952   std::vector< unsigned int > *arg1 = (std::vector< unsigned int > *) 0 ;
87953
87954   arg1 = (std::vector< unsigned int > *)jarg1;
87955   {
87956     try {
87957       delete arg1;
87958     } catch (std::out_of_range& e) {
87959       {
87960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
87961       };
87962     } catch (std::exception& e) {
87963       {
87964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
87965       };
87966     } catch (Dali::DaliException e) {
87967       {
87968         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
87969       };
87970     } catch (...) {
87971       {
87972         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
87973       };
87974     }
87975   }
87976
87977 }
87978
87979
87980 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_0() {
87981   void * jresult ;
87982   std::pair< unsigned int,Dali::Actor > *result = 0 ;
87983
87984   {
87985     try {
87986       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >();
87987     } catch (std::out_of_range& e) {
87988       {
87989         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
87990       };
87991     } catch (std::exception& e) {
87992       {
87993         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
87994       };
87995     } catch (Dali::DaliException e) {
87996       {
87997         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
87998       };
87999     } catch (...) {
88000       {
88001         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88002       };
88003     }
88004   }
88005
88006   jresult = (void *)result;
88007   return jresult;
88008 }
88009
88010
88011 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_1(unsigned int jarg1, void * jarg2) {
88012   void * jresult ;
88013   unsigned int arg1 ;
88014   Dali::Actor arg2 ;
88015   Dali::Actor *argp2 ;
88016   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88017
88018   arg1 = (unsigned int)jarg1;
88019   argp2 = (Dali::Actor *)jarg2;
88020   if (!argp2) {
88021     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
88022     return 0;
88023   }
88024   arg2 = *argp2;
88025   {
88026     try {
88027       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >(arg1,arg2);
88028     } catch (std::out_of_range& e) {
88029       {
88030         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88031       };
88032     } catch (std::exception& e) {
88033       {
88034         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88035       };
88036     } catch (Dali::DaliException e) {
88037       {
88038         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88039       };
88040     } catch (...) {
88041       {
88042         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88043       };
88044     }
88045   }
88046
88047   jresult = (void *)result;
88048   return jresult;
88049 }
88050
88051
88052 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Item__SWIG_2(void * jarg1) {
88053   void * jresult ;
88054   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88055   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88056
88057   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88058   if (!arg1) {
88059     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88060     return 0;
88061   }
88062   {
88063     try {
88064       result = (std::pair< unsigned int,Dali::Actor > *)new std::pair< unsigned int,Dali::Actor >((std::pair< unsigned int,Dali::Actor > const &)*arg1);
88065     } catch (std::out_of_range& e) {
88066       {
88067         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88068       };
88069     } catch (std::exception& e) {
88070       {
88071         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88072       };
88073     } catch (Dali::DaliException e) {
88074       {
88075         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88076       };
88077     } catch (...) {
88078       {
88079         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88080       };
88081     }
88082   }
88083
88084   jresult = (void *)result;
88085   return jresult;
88086 }
88087
88088
88089 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_first_set(void * jarg1, unsigned int jarg2) {
88090   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88091   unsigned int arg2 ;
88092
88093   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88094   arg2 = (unsigned int)jarg2;
88095   if (arg1) (arg1)->first = arg2;
88096 }
88097
88098
88099 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_Item_first_get(void * jarg1) {
88100   unsigned int jresult ;
88101   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88102   unsigned int result;
88103
88104   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88105   result = (unsigned int) ((arg1)->first);
88106   jresult = result;
88107   return jresult;
88108 }
88109
88110
88111 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_Item_second_set(void * jarg1, void * jarg2) {
88112   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88113   Dali::Actor *arg2 = (Dali::Actor *) 0 ;
88114
88115   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88116   arg2 = (Dali::Actor *)jarg2;
88117   if (arg1) (arg1)->second = *arg2;
88118 }
88119
88120
88121 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Item_second_get(void * jarg1) {
88122   void * jresult ;
88123   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88124   Dali::Actor *result = 0 ;
88125
88126   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88127   result = (Dali::Actor *)& ((arg1)->second);
88128   jresult = (void *)result;
88129   return jresult;
88130 }
88131
88132
88133 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Item(void * jarg1) {
88134   std::pair< unsigned int,Dali::Actor > *arg1 = (std::pair< unsigned int,Dali::Actor > *) 0 ;
88135
88136   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88137   {
88138     try {
88139       delete arg1;
88140     } catch (std::out_of_range& e) {
88141       {
88142         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88143       };
88144     } catch (std::exception& e) {
88145       {
88146         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88147       };
88148     } catch (Dali::DaliException e) {
88149       {
88150         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88151       };
88152     } catch (...) {
88153       {
88154         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88155       };
88156     }
88157   }
88158
88159 }
88160
88161
88162 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Clear(void * jarg1) {
88163   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88164
88165   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88166   {
88167     try {
88168       (arg1)->clear();
88169     } catch (std::out_of_range& e) {
88170       {
88171         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88172       };
88173     } catch (std::exception& e) {
88174       {
88175         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88176       };
88177     } catch (Dali::DaliException e) {
88178       {
88179         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88180       };
88181     } catch (...) {
88182       {
88183         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88184       };
88185     }
88186   }
88187
88188 }
88189
88190
88191 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Add(void * jarg1, void * jarg2) {
88192   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88193   std::pair< unsigned int,Dali::Actor > *arg2 = 0 ;
88194
88195   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88196   arg2 = (std::pair< unsigned int,Dali::Actor > *)jarg2;
88197   if (!arg2) {
88198     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88199     return ;
88200   }
88201   {
88202     try {
88203       (arg1)->push_back((std::pair< unsigned int,Dali::Actor > const &)*arg2);
88204     } catch (std::out_of_range& e) {
88205       {
88206         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88207       };
88208     } catch (std::exception& e) {
88209       {
88210         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88211       };
88212     } catch (Dali::DaliException e) {
88213       {
88214         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88215       };
88216     } catch (...) {
88217       {
88218         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88219       };
88220     }
88221   }
88222
88223 }
88224
88225
88226 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_size(void * jarg1) {
88227   unsigned long jresult ;
88228   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88229   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88230
88231   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88232   {
88233     try {
88234       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->size();
88235     } catch (std::out_of_range& e) {
88236       {
88237         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88238       };
88239     } catch (std::exception& e) {
88240       {
88241         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88242       };
88243     } catch (Dali::DaliException e) {
88244       {
88245         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88246       };
88247     } catch (...) {
88248       {
88249         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88250       };
88251     }
88252   }
88253
88254   jresult = (unsigned long)result;
88255   return jresult;
88256 }
88257
88258
88259 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ItemContainer_capacity(void * jarg1) {
88260   unsigned long jresult ;
88261   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88262   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type result;
88263
88264   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88265   {
88266     try {
88267       result = ((std::vector< std::pair< unsigned int,Dali::Actor > > const *)arg1)->capacity();
88268     } catch (std::out_of_range& e) {
88269       {
88270         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88271       };
88272     } catch (std::exception& e) {
88273       {
88274         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88275       };
88276     } catch (Dali::DaliException e) {
88277       {
88278         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88279       };
88280     } catch (...) {
88281       {
88282         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88283       };
88284     }
88285   }
88286
88287   jresult = (unsigned long)result;
88288   return jresult;
88289 }
88290
88291
88292 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_reserve(void * jarg1, unsigned long jarg2) {
88293   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88294   std::vector< std::pair< unsigned int,Dali::Actor > >::size_type arg2 ;
88295
88296   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88297   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > >::size_type)jarg2;
88298   {
88299     try {
88300       (arg1)->reserve(arg2);
88301     } catch (std::out_of_range& e) {
88302       {
88303         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88304       };
88305     } catch (std::exception& e) {
88306       {
88307         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88308       };
88309     } catch (Dali::DaliException e) {
88310       {
88311         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88312       };
88313     } catch (...) {
88314       {
88315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88316       };
88317     }
88318   }
88319
88320 }
88321
88322
88323 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_0() {
88324   void * jresult ;
88325   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88326
88327   {
88328     try {
88329       result = (std::vector< std::pair< unsigned int,Dali::Actor > > *)new std::vector< std::pair< unsigned int,Dali::Actor > >();
88330     } catch (std::out_of_range& e) {
88331       {
88332         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88333       };
88334     } catch (std::exception& e) {
88335       {
88336         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88337       };
88338     } catch (Dali::DaliException e) {
88339       {
88340         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88341       };
88342     } catch (...) {
88343       {
88344         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88345       };
88346     }
88347   }
88348
88349   jresult = (void *)result;
88350   return jresult;
88351 }
88352
88353
88354 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_1(void * jarg1) {
88355   void * jresult ;
88356   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = 0 ;
88357   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88358
88359   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88360   if (!arg1) {
88361     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88362     return 0;
88363   }
88364   {
88365     try {
88366       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);
88367     } catch (std::out_of_range& e) {
88368       {
88369         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88370       };
88371     } catch (std::exception& e) {
88372       {
88373         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88374       };
88375     } catch (Dali::DaliException e) {
88376       {
88377         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88378       };
88379     } catch (...) {
88380       {
88381         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88382       };
88383     }
88384   }
88385
88386   jresult = (void *)result;
88387   return jresult;
88388 }
88389
88390
88391 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ItemContainer__SWIG_2(int jarg1) {
88392   void * jresult ;
88393   int arg1 ;
88394   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88395
88396   arg1 = (int)jarg1;
88397   {
88398     try {
88399       try {
88400         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);
88401       }
88402       catch(std::out_of_range &_e) {
88403         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88404         return 0;
88405       }
88406
88407     } catch (std::out_of_range& e) {
88408       {
88409         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88410       };
88411     } catch (std::exception& e) {
88412       {
88413         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88414       };
88415     } catch (Dali::DaliException e) {
88416       {
88417         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88418       };
88419     } catch (...) {
88420       {
88421         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88422       };
88423     }
88424   }
88425
88426   jresult = (void *)result;
88427   return jresult;
88428 }
88429
88430
88431 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitemcopy(void * jarg1, int jarg2) {
88432   void * jresult ;
88433   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88434   int arg2 ;
88435   std::pair< unsigned int,Dali::Actor > result;
88436
88437   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88438   arg2 = (int)jarg2;
88439   {
88440     try {
88441       try {
88442         result = std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitemcopy(arg1,arg2);
88443       }
88444       catch(std::out_of_range &_e) {
88445         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88446         return 0;
88447       }
88448
88449     } catch (std::out_of_range& e) {
88450       {
88451         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88452       };
88453     } catch (std::exception& e) {
88454       {
88455         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88456       };
88457     } catch (Dali::DaliException e) {
88458       {
88459         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88460       };
88461     } catch (...) {
88462       {
88463         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88464       };
88465     }
88466   }
88467
88468   jresult = new std::pair< unsigned int,Dali::Actor >((const std::pair< unsigned int,Dali::Actor > &)result);
88469   return jresult;
88470 }
88471
88472
88473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_getitem(void * jarg1, int jarg2) {
88474   void * jresult ;
88475   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88476   int arg2 ;
88477   std::pair< unsigned int,Dali::Actor > *result = 0 ;
88478
88479   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88480   arg2 = (int)jarg2;
88481   {
88482     try {
88483       try {
88484         result = (std::pair< unsigned int,Dali::Actor > *) &std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__getitem(arg1,arg2);
88485       }
88486       catch(std::out_of_range &_e) {
88487         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88488         return 0;
88489       }
88490
88491     } catch (std::out_of_range& e) {
88492       {
88493         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88494       };
88495     } catch (std::exception& e) {
88496       {
88497         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88498       };
88499     } catch (Dali::DaliException e) {
88500       {
88501         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88502       };
88503     } catch (...) {
88504       {
88505         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88506       };
88507     }
88508   }
88509
88510   jresult = (void *)result;
88511   return jresult;
88512 }
88513
88514
88515 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
88516   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88517   int arg2 ;
88518   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88519
88520   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88521   arg2 = (int)jarg2;
88522   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88523   if (!arg3) {
88524     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88525     return ;
88526   }
88527   {
88528     try {
88529       try {
88530         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);
88531       }
88532       catch(std::out_of_range &_e) {
88533         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88534         return ;
88535       }
88536
88537     } catch (std::out_of_range& e) {
88538       {
88539         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88540       };
88541     } catch (std::exception& e) {
88542       {
88543         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88544       };
88545     } catch (Dali::DaliException e) {
88546       {
88547         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88548       };
88549     } catch (...) {
88550       {
88551         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88552       };
88553     }
88554   }
88555
88556 }
88557
88558
88559 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_AddRange(void * jarg1, void * jarg2) {
88560   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88561   std::vector< std::pair< unsigned int,Dali::Actor > > *arg2 = 0 ;
88562
88563   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88564   arg2 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg2;
88565   if (!arg2) {
88566     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88567     return ;
88568   }
88569   {
88570     try {
88571       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);
88572     } catch (std::out_of_range& e) {
88573       {
88574         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88575       };
88576     } catch (std::exception& e) {
88577       {
88578         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88579       };
88580     } catch (Dali::DaliException e) {
88581       {
88582         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88583       };
88584     } catch (...) {
88585       {
88586         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88587       };
88588     }
88589   }
88590
88591 }
88592
88593
88594 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
88595   void * jresult ;
88596   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88597   int arg2 ;
88598   int arg3 ;
88599   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88600
88601   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88602   arg2 = (int)jarg2;
88603   arg3 = (int)jarg3;
88604   {
88605     try {
88606       try {
88607         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);
88608       }
88609       catch(std::out_of_range &_e) {
88610         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88611         return 0;
88612       }
88613       catch(std::invalid_argument &_e) {
88614         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88615         return 0;
88616       }
88617
88618     } catch (std::out_of_range& e) {
88619       {
88620         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88621       };
88622     } catch (std::exception& e) {
88623       {
88624         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88625       };
88626     } catch (Dali::DaliException e) {
88627       {
88628         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88629       };
88630     } catch (...) {
88631       {
88632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88633       };
88634     }
88635   }
88636
88637   jresult = (void *)result;
88638   return jresult;
88639 }
88640
88641
88642 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
88643   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88644   int arg2 ;
88645   std::pair< unsigned int,Dali::Actor > *arg3 = 0 ;
88646
88647   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88648   arg2 = (int)jarg2;
88649   arg3 = (std::pair< unsigned int,Dali::Actor > *)jarg3;
88650   if (!arg3) {
88651     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88652     return ;
88653   }
88654   {
88655     try {
88656       try {
88657         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);
88658       }
88659       catch(std::out_of_range &_e) {
88660         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88661         return ;
88662       }
88663
88664     } catch (std::out_of_range& e) {
88665       {
88666         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88667       };
88668     } catch (std::exception& e) {
88669       {
88670         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88671       };
88672     } catch (Dali::DaliException e) {
88673       {
88674         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88675       };
88676     } catch (...) {
88677       {
88678         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88679       };
88680     }
88681   }
88682
88683 }
88684
88685
88686 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
88687   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88688   int arg2 ;
88689   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88690
88691   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88692   arg2 = (int)jarg2;
88693   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88694   if (!arg3) {
88695     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88696     return ;
88697   }
88698   {
88699     try {
88700       try {
88701         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);
88702       }
88703       catch(std::out_of_range &_e) {
88704         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88705         return ;
88706       }
88707
88708     } catch (std::out_of_range& e) {
88709       {
88710         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88711       };
88712     } catch (std::exception& e) {
88713       {
88714         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88715       };
88716     } catch (Dali::DaliException e) {
88717       {
88718         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88719       };
88720     } catch (...) {
88721       {
88722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88723       };
88724     }
88725   }
88726
88727 }
88728
88729
88730 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveAt(void * jarg1, int jarg2) {
88731   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88732   int arg2 ;
88733
88734   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88735   arg2 = (int)jarg2;
88736   {
88737     try {
88738       try {
88739         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveAt(arg1,arg2);
88740       }
88741       catch(std::out_of_range &_e) {
88742         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88743         return ;
88744       }
88745
88746     } catch (std::out_of_range& e) {
88747       {
88748         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88749       };
88750     } catch (std::exception& e) {
88751       {
88752         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88753       };
88754     } catch (Dali::DaliException e) {
88755       {
88756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88757       };
88758     } catch (...) {
88759       {
88760         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88761       };
88762     }
88763   }
88764
88765 }
88766
88767
88768 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
88769   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88770   int arg2 ;
88771   int arg3 ;
88772
88773   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88774   arg2 = (int)jarg2;
88775   arg3 = (int)jarg3;
88776   {
88777     try {
88778       try {
88779         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__RemoveRange(arg1,arg2,arg3);
88780       }
88781       catch(std::out_of_range &_e) {
88782         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88783         return ;
88784       }
88785       catch(std::invalid_argument &_e) {
88786         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88787         return ;
88788       }
88789
88790     } catch (std::out_of_range& e) {
88791       {
88792         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88793       };
88794     } catch (std::exception& e) {
88795       {
88796         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88797       };
88798     } catch (Dali::DaliException e) {
88799       {
88800         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88801       };
88802     } catch (...) {
88803       {
88804         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88805       };
88806     }
88807   }
88808
88809 }
88810
88811
88812 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ItemContainer_Repeat(void * jarg1, int jarg2) {
88813   void * jresult ;
88814   std::pair< unsigned int,Dali::Actor > *arg1 = 0 ;
88815   int arg2 ;
88816   std::vector< std::pair< unsigned int,Dali::Actor > > *result = 0 ;
88817
88818   arg1 = (std::pair< unsigned int,Dali::Actor > *)jarg1;
88819   if (!arg1) {
88820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::pair< unsigned int,Dali::Actor > const & type is null", 0);
88821     return 0;
88822   }
88823   arg2 = (int)jarg2;
88824   {
88825     try {
88826       try {
88827         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);
88828       }
88829       catch(std::out_of_range &_e) {
88830         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88831         return 0;
88832       }
88833
88834     } catch (std::out_of_range& e) {
88835       {
88836         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
88837       };
88838     } catch (std::exception& e) {
88839       {
88840         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
88841       };
88842     } catch (Dali::DaliException e) {
88843       {
88844         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
88845       };
88846     } catch (...) {
88847       {
88848         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
88849       };
88850     }
88851   }
88852
88853   jresult = (void *)result;
88854   return jresult;
88855 }
88856
88857
88858 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_0(void * jarg1) {
88859   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88860
88861   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88862   {
88863     try {
88864       std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_0(arg1);
88865     } catch (std::out_of_range& e) {
88866       {
88867         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88868       };
88869     } catch (std::exception& e) {
88870       {
88871         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88872       };
88873     } catch (Dali::DaliException e) {
88874       {
88875         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88876       };
88877     } catch (...) {
88878       {
88879         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88880       };
88881     }
88882   }
88883
88884 }
88885
88886
88887 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
88888   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88889   int arg2 ;
88890   int arg3 ;
88891
88892   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88893   arg2 = (int)jarg2;
88894   arg3 = (int)jarg3;
88895   {
88896     try {
88897       try {
88898         std_vector_Sl_std_pair_Sl_unsigned_SS_int_Sc_Dali_Actor_Sg__Sg__Reverse__SWIG_1(arg1,arg2,arg3);
88899       }
88900       catch(std::out_of_range &_e) {
88901         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88902         return ;
88903       }
88904       catch(std::invalid_argument &_e) {
88905         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
88906         return ;
88907       }
88908
88909     } catch (std::out_of_range& e) {
88910       {
88911         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88912       };
88913     } catch (std::exception& e) {
88914       {
88915         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88916       };
88917     } catch (Dali::DaliException e) {
88918       {
88919         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88920       };
88921     } catch (...) {
88922       {
88923         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88924       };
88925     }
88926   }
88927
88928 }
88929
88930
88931 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ItemContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
88932   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88933   int arg2 ;
88934   std::vector< std::pair< unsigned int,Dali::Actor > > *arg3 = 0 ;
88935
88936   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88937   arg2 = (int)jarg2;
88938   arg3 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg3;
88939   if (!arg3) {
88940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< std::pair< unsigned int,Dali::Actor > > const & type is null", 0);
88941     return ;
88942   }
88943   {
88944     try {
88945       try {
88946         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);
88947       }
88948       catch(std::out_of_range &_e) {
88949         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
88950         return ;
88951       }
88952
88953     } catch (std::out_of_range& e) {
88954       {
88955         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88956       };
88957     } catch (std::exception& e) {
88958       {
88959         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88960       };
88961     } catch (Dali::DaliException e) {
88962       {
88963         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88964       };
88965     } catch (...) {
88966       {
88967         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88968       };
88969     }
88970   }
88971
88972 }
88973
88974
88975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ItemContainer(void * jarg1) {
88976   std::vector< std::pair< unsigned int,Dali::Actor > > *arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *) 0 ;
88977
88978   arg1 = (std::vector< std::pair< unsigned int,Dali::Actor > > *)jarg1;
88979   {
88980     try {
88981       delete arg1;
88982     } catch (std::out_of_range& e) {
88983       {
88984         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
88985       };
88986     } catch (std::exception& e) {
88987       {
88988         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
88989       };
88990     } catch (Dali::DaliException e) {
88991       {
88992         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
88993       };
88994     } catch (...) {
88995       {
88996         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
88997       };
88998     }
88999   }
89000
89001 }
89002
89003
89004 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Clear(void * jarg1) {
89005   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89006
89007   arg1 = (std::vector< Dali::Actor > *)jarg1;
89008   {
89009     try {
89010       (arg1)->clear();
89011     } catch (std::out_of_range& e) {
89012       {
89013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89014       };
89015     } catch (std::exception& e) {
89016       {
89017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89018       };
89019     } catch (Dali::DaliException e) {
89020       {
89021         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89022       };
89023     } catch (...) {
89024       {
89025         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89026       };
89027     }
89028   }
89029
89030 }
89031
89032
89033 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Add(void * jarg1, void * jarg2) {
89034   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89035   Dali::Actor *arg2 = 0 ;
89036
89037   arg1 = (std::vector< Dali::Actor > *)jarg1;
89038   arg2 = (Dali::Actor *)jarg2;
89039   if (!arg2) {
89040     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89041     return ;
89042   }
89043   {
89044     try {
89045       (arg1)->push_back((Dali::Actor const &)*arg2);
89046     } catch (std::out_of_range& e) {
89047       {
89048         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89049       };
89050     } catch (std::exception& e) {
89051       {
89052         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89053       };
89054     } catch (Dali::DaliException e) {
89055       {
89056         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89057       };
89058     } catch (...) {
89059       {
89060         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89061       };
89062     }
89063   }
89064
89065 }
89066
89067
89068 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_size(void * jarg1) {
89069   unsigned long jresult ;
89070   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89071   std::vector< Dali::Actor >::size_type result;
89072
89073   arg1 = (std::vector< Dali::Actor > *)jarg1;
89074   {
89075     try {
89076       result = ((std::vector< Dali::Actor > const *)arg1)->size();
89077     } catch (std::out_of_range& e) {
89078       {
89079         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89080       };
89081     } catch (std::exception& e) {
89082       {
89083         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89084       };
89085     } catch (Dali::DaliException e) {
89086       {
89087         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89088       };
89089     } catch (...) {
89090       {
89091         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89092       };
89093     }
89094   }
89095
89096   jresult = (unsigned long)result;
89097   return jresult;
89098 }
89099
89100
89101 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ActorContainer_capacity(void * jarg1) {
89102   unsigned long jresult ;
89103   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89104   std::vector< Dali::Actor >::size_type result;
89105
89106   arg1 = (std::vector< Dali::Actor > *)jarg1;
89107   {
89108     try {
89109       result = ((std::vector< Dali::Actor > const *)arg1)->capacity();
89110     } catch (std::out_of_range& e) {
89111       {
89112         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89113       };
89114     } catch (std::exception& e) {
89115       {
89116         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89117       };
89118     } catch (Dali::DaliException e) {
89119       {
89120         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89121       };
89122     } catch (...) {
89123       {
89124         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89125       };
89126     }
89127   }
89128
89129   jresult = (unsigned long)result;
89130   return jresult;
89131 }
89132
89133
89134 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_reserve(void * jarg1, unsigned long jarg2) {
89135   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89136   std::vector< Dali::Actor >::size_type arg2 ;
89137
89138   arg1 = (std::vector< Dali::Actor > *)jarg1;
89139   arg2 = (std::vector< Dali::Actor >::size_type)jarg2;
89140   {
89141     try {
89142       (arg1)->reserve(arg2);
89143     } catch (std::out_of_range& e) {
89144       {
89145         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89146       };
89147     } catch (std::exception& e) {
89148       {
89149         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89150       };
89151     } catch (Dali::DaliException e) {
89152       {
89153         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89154       };
89155     } catch (...) {
89156       {
89157         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89158       };
89159     }
89160   }
89161
89162 }
89163
89164
89165 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_0() {
89166   void * jresult ;
89167   std::vector< Dali::Actor > *result = 0 ;
89168
89169   {
89170     try {
89171       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >();
89172     } catch (std::out_of_range& e) {
89173       {
89174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89175       };
89176     } catch (std::exception& e) {
89177       {
89178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89179       };
89180     } catch (Dali::DaliException e) {
89181       {
89182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89183       };
89184     } catch (...) {
89185       {
89186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89187       };
89188     }
89189   }
89190
89191   jresult = (void *)result;
89192   return jresult;
89193 }
89194
89195
89196 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_1(void * jarg1) {
89197   void * jresult ;
89198   std::vector< Dali::Actor > *arg1 = 0 ;
89199   std::vector< Dali::Actor > *result = 0 ;
89200
89201   arg1 = (std::vector< Dali::Actor > *)jarg1;
89202   if (!arg1) {
89203     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89204     return 0;
89205   }
89206   {
89207     try {
89208       result = (std::vector< Dali::Actor > *)new std::vector< Dali::Actor >((std::vector< Dali::Actor > const &)*arg1);
89209     } catch (std::out_of_range& e) {
89210       {
89211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89212       };
89213     } catch (std::exception& e) {
89214       {
89215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89216       };
89217     } catch (Dali::DaliException e) {
89218       {
89219         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89220       };
89221     } catch (...) {
89222       {
89223         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89224       };
89225     }
89226   }
89227
89228   jresult = (void *)result;
89229   return jresult;
89230 }
89231
89232
89233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ActorContainer__SWIG_2(int jarg1) {
89234   void * jresult ;
89235   int arg1 ;
89236   std::vector< Dali::Actor > *result = 0 ;
89237
89238   arg1 = (int)jarg1;
89239   {
89240     try {
89241       try {
89242         result = (std::vector< Dali::Actor > *)new_std_vector_Sl_Dali_Actor_Sg___SWIG_2(arg1);
89243       }
89244       catch(std::out_of_range &_e) {
89245         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89246         return 0;
89247       }
89248
89249     } catch (std::out_of_range& e) {
89250       {
89251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89252       };
89253     } catch (std::exception& e) {
89254       {
89255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89256       };
89257     } catch (Dali::DaliException e) {
89258       {
89259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89260       };
89261     } catch (...) {
89262       {
89263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89264       };
89265     }
89266   }
89267
89268   jresult = (void *)result;
89269   return jresult;
89270 }
89271
89272
89273 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitemcopy(void * jarg1, int jarg2) {
89274   void * jresult ;
89275   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89276   int arg2 ;
89277   Dali::Actor result;
89278
89279   arg1 = (std::vector< Dali::Actor > *)jarg1;
89280   arg2 = (int)jarg2;
89281   {
89282     try {
89283       try {
89284         result = std_vector_Sl_Dali_Actor_Sg__getitemcopy(arg1,arg2);
89285       }
89286       catch(std::out_of_range &_e) {
89287         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89288         return 0;
89289       }
89290
89291     } catch (std::out_of_range& e) {
89292       {
89293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89294       };
89295     } catch (std::exception& e) {
89296       {
89297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89298       };
89299     } catch (Dali::DaliException e) {
89300       {
89301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89302       };
89303     } catch (...) {
89304       {
89305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89306       };
89307     }
89308   }
89309
89310   jresult = new Dali::Actor((const Dali::Actor &)result);
89311   return jresult;
89312 }
89313
89314
89315 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_getitem(void * jarg1, int jarg2) {
89316   void * jresult ;
89317   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89318   int arg2 ;
89319   Dali::Actor *result = 0 ;
89320
89321   arg1 = (std::vector< Dali::Actor > *)jarg1;
89322   arg2 = (int)jarg2;
89323   {
89324     try {
89325       try {
89326         result = (Dali::Actor *) &std_vector_Sl_Dali_Actor_Sg__getitem(arg1,arg2);
89327       }
89328       catch(std::out_of_range &_e) {
89329         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89330         return 0;
89331       }
89332
89333     } catch (std::out_of_range& e) {
89334       {
89335         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89336       };
89337     } catch (std::exception& e) {
89338       {
89339         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89340       };
89341     } catch (Dali::DaliException e) {
89342       {
89343         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89344       };
89345     } catch (...) {
89346       {
89347         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89348       };
89349     }
89350   }
89351
89352   jresult = (void *)result;
89353   return jresult;
89354 }
89355
89356
89357 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_setitem(void * jarg1, int jarg2, void * jarg3) {
89358   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89359   int arg2 ;
89360   Dali::Actor *arg3 = 0 ;
89361
89362   arg1 = (std::vector< Dali::Actor > *)jarg1;
89363   arg2 = (int)jarg2;
89364   arg3 = (Dali::Actor *)jarg3;
89365   if (!arg3) {
89366     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89367     return ;
89368   }
89369   {
89370     try {
89371       try {
89372         std_vector_Sl_Dali_Actor_Sg__setitem(arg1,arg2,(Dali::Actor const &)*arg3);
89373       }
89374       catch(std::out_of_range &_e) {
89375         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89376         return ;
89377       }
89378
89379     } catch (std::out_of_range& e) {
89380       {
89381         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89382       };
89383     } catch (std::exception& e) {
89384       {
89385         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89386       };
89387     } catch (Dali::DaliException e) {
89388       {
89389         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89390       };
89391     } catch (...) {
89392       {
89393         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89394       };
89395     }
89396   }
89397
89398 }
89399
89400
89401 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_AddRange(void * jarg1, void * jarg2) {
89402   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89403   std::vector< Dali::Actor > *arg2 = 0 ;
89404
89405   arg1 = (std::vector< Dali::Actor > *)jarg1;
89406   arg2 = (std::vector< Dali::Actor > *)jarg2;
89407   if (!arg2) {
89408     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89409     return ;
89410   }
89411   {
89412     try {
89413       std_vector_Sl_Dali_Actor_Sg__AddRange(arg1,(std::vector< Dali::Actor > const &)*arg2);
89414     } catch (std::out_of_range& e) {
89415       {
89416         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89417       };
89418     } catch (std::exception& e) {
89419       {
89420         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89421       };
89422     } catch (Dali::DaliException e) {
89423       {
89424         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89425       };
89426     } catch (...) {
89427       {
89428         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89429       };
89430     }
89431   }
89432
89433 }
89434
89435
89436 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_GetRange(void * jarg1, int jarg2, int jarg3) {
89437   void * jresult ;
89438   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89439   int arg2 ;
89440   int arg3 ;
89441   std::vector< Dali::Actor > *result = 0 ;
89442
89443   arg1 = (std::vector< Dali::Actor > *)jarg1;
89444   arg2 = (int)jarg2;
89445   arg3 = (int)jarg3;
89446   {
89447     try {
89448       try {
89449         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__GetRange(arg1,arg2,arg3);
89450       }
89451       catch(std::out_of_range &_e) {
89452         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89453         return 0;
89454       }
89455       catch(std::invalid_argument &_e) {
89456         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89457         return 0;
89458       }
89459
89460     } catch (std::out_of_range& e) {
89461       {
89462         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89463       };
89464     } catch (std::exception& e) {
89465       {
89466         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89467       };
89468     } catch (Dali::DaliException e) {
89469       {
89470         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89471       };
89472     } catch (...) {
89473       {
89474         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89475       };
89476     }
89477   }
89478
89479   jresult = (void *)result;
89480   return jresult;
89481 }
89482
89483
89484 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Insert(void * jarg1, int jarg2, void * jarg3) {
89485   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89486   int arg2 ;
89487   Dali::Actor *arg3 = 0 ;
89488
89489   arg1 = (std::vector< Dali::Actor > *)jarg1;
89490   arg2 = (int)jarg2;
89491   arg3 = (Dali::Actor *)jarg3;
89492   if (!arg3) {
89493     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89494     return ;
89495   }
89496   {
89497     try {
89498       try {
89499         std_vector_Sl_Dali_Actor_Sg__Insert(arg1,arg2,(Dali::Actor const &)*arg3);
89500       }
89501       catch(std::out_of_range &_e) {
89502         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89503         return ;
89504       }
89505
89506     } catch (std::out_of_range& e) {
89507       {
89508         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89509       };
89510     } catch (std::exception& e) {
89511       {
89512         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89513       };
89514     } catch (Dali::DaliException e) {
89515       {
89516         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89517       };
89518     } catch (...) {
89519       {
89520         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89521       };
89522     }
89523   }
89524
89525 }
89526
89527
89528 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_InsertRange(void * jarg1, int jarg2, void * jarg3) {
89529   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89530   int arg2 ;
89531   std::vector< Dali::Actor > *arg3 = 0 ;
89532
89533   arg1 = (std::vector< Dali::Actor > *)jarg1;
89534   arg2 = (int)jarg2;
89535   arg3 = (std::vector< Dali::Actor > *)jarg3;
89536   if (!arg3) {
89537     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89538     return ;
89539   }
89540   {
89541     try {
89542       try {
89543         std_vector_Sl_Dali_Actor_Sg__InsertRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89544       }
89545       catch(std::out_of_range &_e) {
89546         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89547         return ;
89548       }
89549
89550     } catch (std::out_of_range& e) {
89551       {
89552         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89553       };
89554     } catch (std::exception& e) {
89555       {
89556         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89557       };
89558     } catch (Dali::DaliException e) {
89559       {
89560         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89561       };
89562     } catch (...) {
89563       {
89564         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89565       };
89566     }
89567   }
89568
89569 }
89570
89571
89572 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveAt(void * jarg1, int jarg2) {
89573   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89574   int arg2 ;
89575
89576   arg1 = (std::vector< Dali::Actor > *)jarg1;
89577   arg2 = (int)jarg2;
89578   {
89579     try {
89580       try {
89581         std_vector_Sl_Dali_Actor_Sg__RemoveAt(arg1,arg2);
89582       }
89583       catch(std::out_of_range &_e) {
89584         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89585         return ;
89586       }
89587
89588     } catch (std::out_of_range& e) {
89589       {
89590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89591       };
89592     } catch (std::exception& e) {
89593       {
89594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89595       };
89596     } catch (Dali::DaliException e) {
89597       {
89598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89599       };
89600     } catch (...) {
89601       {
89602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89603       };
89604     }
89605   }
89606
89607 }
89608
89609
89610 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_RemoveRange(void * jarg1, int jarg2, int jarg3) {
89611   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89612   int arg2 ;
89613   int arg3 ;
89614
89615   arg1 = (std::vector< Dali::Actor > *)jarg1;
89616   arg2 = (int)jarg2;
89617   arg3 = (int)jarg3;
89618   {
89619     try {
89620       try {
89621         std_vector_Sl_Dali_Actor_Sg__RemoveRange(arg1,arg2,arg3);
89622       }
89623       catch(std::out_of_range &_e) {
89624         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89625         return ;
89626       }
89627       catch(std::invalid_argument &_e) {
89628         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89629         return ;
89630       }
89631
89632     } catch (std::out_of_range& e) {
89633       {
89634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89635       };
89636     } catch (std::exception& e) {
89637       {
89638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89639       };
89640     } catch (Dali::DaliException e) {
89641       {
89642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89643       };
89644     } catch (...) {
89645       {
89646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89647       };
89648     }
89649   }
89650
89651 }
89652
89653
89654 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_ActorContainer_Repeat(void * jarg1, int jarg2) {
89655   void * jresult ;
89656   Dali::Actor *arg1 = 0 ;
89657   int arg2 ;
89658   std::vector< Dali::Actor > *result = 0 ;
89659
89660   arg1 = (Dali::Actor *)jarg1;
89661   if (!arg1) {
89662     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Actor const & type is null", 0);
89663     return 0;
89664   }
89665   arg2 = (int)jarg2;
89666   {
89667     try {
89668       try {
89669         result = (std::vector< Dali::Actor > *)std_vector_Sl_Dali_Actor_Sg__Repeat((Dali::Actor const &)*arg1,arg2);
89670       }
89671       catch(std::out_of_range &_e) {
89672         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89673         return 0;
89674       }
89675
89676     } catch (std::out_of_range& e) {
89677       {
89678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89679       };
89680     } catch (std::exception& e) {
89681       {
89682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89683       };
89684     } catch (Dali::DaliException e) {
89685       {
89686         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89687       };
89688     } catch (...) {
89689       {
89690         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89691       };
89692     }
89693   }
89694
89695   jresult = (void *)result;
89696   return jresult;
89697 }
89698
89699
89700 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_0(void * jarg1) {
89701   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89702
89703   arg1 = (std::vector< Dali::Actor > *)jarg1;
89704   {
89705     try {
89706       std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_0(arg1);
89707     } catch (std::out_of_range& e) {
89708       {
89709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89710       };
89711     } catch (std::exception& e) {
89712       {
89713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89714       };
89715     } catch (Dali::DaliException e) {
89716       {
89717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89718       };
89719     } catch (...) {
89720       {
89721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89722       };
89723     }
89724   }
89725
89726 }
89727
89728
89729 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_Reverse__SWIG_1(void * jarg1, int jarg2, int jarg3) {
89730   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89731   int arg2 ;
89732   int arg3 ;
89733
89734   arg1 = (std::vector< Dali::Actor > *)jarg1;
89735   arg2 = (int)jarg2;
89736   arg3 = (int)jarg3;
89737   {
89738     try {
89739       try {
89740         std_vector_Sl_Dali_Actor_Sg__Reverse__SWIG_1(arg1,arg2,arg3);
89741       }
89742       catch(std::out_of_range &_e) {
89743         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89744         return ;
89745       }
89746       catch(std::invalid_argument &_e) {
89747         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentException, (&_e)->what(), "");
89748         return ;
89749       }
89750
89751     } catch (std::out_of_range& e) {
89752       {
89753         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89754       };
89755     } catch (std::exception& e) {
89756       {
89757         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89758       };
89759     } catch (Dali::DaliException e) {
89760       {
89761         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89762       };
89763     } catch (...) {
89764       {
89765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89766       };
89767     }
89768   }
89769
89770 }
89771
89772
89773 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ActorContainer_SetRange(void * jarg1, int jarg2, void * jarg3) {
89774   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89775   int arg2 ;
89776   std::vector< Dali::Actor > *arg3 = 0 ;
89777
89778   arg1 = (std::vector< Dali::Actor > *)jarg1;
89779   arg2 = (int)jarg2;
89780   arg3 = (std::vector< Dali::Actor > *)jarg3;
89781   if (!arg3) {
89782     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "std::vector< Dali::Actor > const & type is null", 0);
89783     return ;
89784   }
89785   {
89786     try {
89787       try {
89788         std_vector_Sl_Dali_Actor_Sg__SetRange(arg1,arg2,(std::vector< Dali::Actor > const &)*arg3);
89789       }
89790       catch(std::out_of_range &_e) {
89791         SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, 0, (&_e)->what());
89792         return ;
89793       }
89794
89795     } catch (std::out_of_range& e) {
89796       {
89797         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89798       };
89799     } catch (std::exception& e) {
89800       {
89801         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89802       };
89803     } catch (Dali::DaliException e) {
89804       {
89805         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89806       };
89807     } catch (...) {
89808       {
89809         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89810       };
89811     }
89812   }
89813
89814 }
89815
89816
89817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ActorContainer(void * jarg1) {
89818   std::vector< Dali::Actor > *arg1 = (std::vector< Dali::Actor > *) 0 ;
89819
89820   arg1 = (std::vector< Dali::Actor > *)jarg1;
89821   {
89822     try {
89823       delete arg1;
89824     } catch (std::out_of_range& e) {
89825       {
89826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89827       };
89828     } catch (std::exception& e) {
89829       {
89830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89831       };
89832     } catch (Dali::DaliException e) {
89833       {
89834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89835       };
89836     } catch (...) {
89837       {
89838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89839       };
89840     }
89841   }
89842
89843 }
89844
89845
89846 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Empty(void * jarg1) {
89847   unsigned int jresult ;
89848   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89849   bool result;
89850
89851   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89852   {
89853     try {
89854       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89855     } catch (std::out_of_range& e) {
89856       {
89857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89858       };
89859     } catch (std::exception& e) {
89860       {
89861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89862       };
89863     } catch (Dali::DaliException e) {
89864       {
89865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89866       };
89867     } catch (...) {
89868       {
89869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89870       };
89871     }
89872   }
89873
89874   jresult = result;
89875   return jresult;
89876 }
89877
89878
89879 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_GetConnectionCount(void * jarg1) {
89880   unsigned long jresult ;
89881   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89882   std::size_t result;
89883
89884   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89885   {
89886     try {
89887       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > const *)arg1);
89888     } catch (std::out_of_range& e) {
89889       {
89890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89891       };
89892     } catch (std::exception& e) {
89893       {
89894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89895       };
89896     } catch (Dali::DaliException e) {
89897       {
89898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
89899       };
89900     } catch (...) {
89901       {
89902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
89903       };
89904     }
89905   }
89906
89907   jresult = (unsigned long)result;
89908   return jresult;
89909 }
89910
89911
89912 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Connect(void * jarg1, void * jarg2) {
89913   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89914   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89915
89916   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89917   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89918   {
89919     try {
89920       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Connect(arg1,arg2);
89921     } catch (std::out_of_range& e) {
89922       {
89923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89924       };
89925     } catch (std::exception& e) {
89926       {
89927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89928       };
89929     } catch (Dali::DaliException e) {
89930       {
89931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89932       };
89933     } catch (...) {
89934       {
89935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89936       };
89937     }
89938   }
89939
89940 }
89941
89942
89943 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Disconnect(void * jarg1, void * jarg2) {
89944   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89945   bool (*arg2)(Dali::Toolkit::AccessibilityManager &) = (bool (*)(Dali::Toolkit::AccessibilityManager &)) 0 ;
89946
89947   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89948   arg2 = (bool (*)(Dali::Toolkit::AccessibilityManager &))jarg2;
89949   {
89950     try {
89951       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Disconnect(arg1,arg2);
89952     } catch (std::out_of_range& e) {
89953       {
89954         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
89955       };
89956     } catch (std::exception& e) {
89957       {
89958         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
89959       };
89960     } catch (Dali::DaliException e) {
89961       {
89962         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
89963       };
89964     } catch (...) {
89965       {
89966         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
89967       };
89968     }
89969   }
89970
89971 }
89972
89973
89974 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityActionSignal_Emit(void * jarg1, void * jarg2) {
89975   unsigned int jresult ;
89976   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
89977   Dali::Toolkit::AccessibilityManager *arg2 = 0 ;
89978   bool result;
89979
89980   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
89981   arg2 = (Dali::Toolkit::AccessibilityManager *)jarg2;
89982   if (!arg2) {
89983     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::AccessibilityManager & type is null", 0);
89984     return 0;
89985   }
89986   {
89987     try {
89988       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_AccessibilityManager_SA__SP__Sg__Emit(arg1,*arg2);
89989     } catch (std::out_of_range& e) {
89990       {
89991         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
89992       };
89993     } catch (std::exception& e) {
89994       {
89995         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
89996       };
89997     } catch (Dali::DaliException e) {
89998       {
89999         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90000       };
90001     } catch (...) {
90002       {
90003         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90004       };
90005     }
90006   }
90007
90008   jresult = result;
90009   return jresult;
90010 }
90011
90012
90013 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityActionSignal() {
90014   void * jresult ;
90015   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *result = 0 ;
90016
90017   {
90018     try {
90019       result = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)new Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) >();
90020     } catch (std::out_of_range& e) {
90021       {
90022         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90023       };
90024     } catch (std::exception& e) {
90025       {
90026         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90027       };
90028     } catch (Dali::DaliException e) {
90029       {
90030         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90031       };
90032     } catch (...) {
90033       {
90034         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90035       };
90036     }
90037   }
90038
90039   jresult = (void *)result;
90040   return jresult;
90041 }
90042
90043
90044 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityActionSignal(void * jarg1) {
90045   Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *) 0 ;
90046
90047   arg1 = (Dali::Signal< bool (Dali::Toolkit::AccessibilityManager &) > *)jarg1;
90048   {
90049     try {
90050       delete arg1;
90051     } catch (std::out_of_range& e) {
90052       {
90053         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90054       };
90055     } catch (std::exception& e) {
90056       {
90057         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90058       };
90059     } catch (Dali::DaliException e) {
90060       {
90061         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90062       };
90063     } catch (...) {
90064       {
90065         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90066       };
90067     }
90068   }
90069
90070 }
90071
90072
90073 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Empty(void * jarg1) {
90074   unsigned int jresult ;
90075   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90076   bool result;
90077
90078   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90079   {
90080     try {
90081       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);
90082     } catch (std::out_of_range& e) {
90083       {
90084         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90085       };
90086     } catch (std::exception& e) {
90087       {
90088         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90089       };
90090     } catch (Dali::DaliException e) {
90091       {
90092         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90093       };
90094     } catch (...) {
90095       {
90096         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90097       };
90098     }
90099   }
90100
90101   jresult = result;
90102   return jresult;
90103 }
90104
90105
90106 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_GetConnectionCount(void * jarg1) {
90107   unsigned long jresult ;
90108   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90109   std::size_t result;
90110
90111   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90112   {
90113     try {
90114       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);
90115     } catch (std::out_of_range& e) {
90116       {
90117         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90118       };
90119     } catch (std::exception& e) {
90120       {
90121         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90122       };
90123     } catch (Dali::DaliException e) {
90124       {
90125         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90126       };
90127     } catch (...) {
90128       {
90129         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90130       };
90131     }
90132   }
90133
90134   jresult = (unsigned long)result;
90135   return jresult;
90136 }
90137
90138
90139 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Connect(void * jarg1, void * jarg2) {
90140   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90141   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90142
90143   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90144   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90145   {
90146     try {
90147       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Connect(arg1,arg2);
90148     } catch (std::out_of_range& e) {
90149       {
90150         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90151       };
90152     } catch (std::exception& e) {
90153       {
90154         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90155       };
90156     } catch (Dali::DaliException e) {
90157       {
90158         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90159       };
90160     } catch (...) {
90161       {
90162         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90163       };
90164     }
90165   }
90166
90167 }
90168
90169
90170 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Disconnect(void * jarg1, void * jarg2) {
90171   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90172   void (*arg2)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)) 0 ;
90173
90174   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90175   arg2 = (void (*)(Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection))jarg2;
90176   {
90177     try {
90178       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Disconnect(arg1,arg2);
90179     } catch (std::out_of_range& e) {
90180       {
90181         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90182       };
90183     } catch (std::exception& e) {
90184       {
90185         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90186       };
90187     } catch (Dali::DaliException e) {
90188       {
90189         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90190       };
90191     } catch (...) {
90192       {
90193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90194       };
90195     }
90196   }
90197
90198 }
90199
90200
90201 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_AccessibilityFocusOvershotSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90202   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90203   Dali::Actor arg2 ;
90204   Dali::Toolkit::AccessibilityManager::FocusOvershotDirection arg3 ;
90205   Dali::Actor *argp2 ;
90206
90207   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90208   argp2 = (Dali::Actor *)jarg2;
90209   if (!argp2) {
90210     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90211     return ;
90212   }
90213   arg2 = *argp2;
90214   arg3 = (Dali::Toolkit::AccessibilityManager::FocusOvershotDirection)jarg3;
90215   {
90216     try {
90217       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Toolkit_AccessibilityManager_FocusOvershotDirection_SP__Sg__Emit(arg1,arg2,arg3);
90218     } catch (std::out_of_range& e) {
90219       {
90220         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90221       };
90222     } catch (std::exception& e) {
90223       {
90224         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90225       };
90226     } catch (Dali::DaliException e) {
90227       {
90228         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90229       };
90230     } catch (...) {
90231       {
90232         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90233       };
90234     }
90235   }
90236
90237 }
90238
90239
90240 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_AccessibilityFocusOvershotSignal() {
90241   void * jresult ;
90242   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *result = 0 ;
90243
90244   {
90245     try {
90246       result = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)new Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) >();
90247     } catch (std::out_of_range& e) {
90248       {
90249         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90250       };
90251     } catch (std::exception& e) {
90252       {
90253         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90254       };
90255     } catch (Dali::DaliException e) {
90256       {
90257         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90258       };
90259     } catch (...) {
90260       {
90261         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90262       };
90263     }
90264   }
90265
90266   jresult = (void *)result;
90267   return jresult;
90268 }
90269
90270
90271 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_AccessibilityFocusOvershotSignal(void * jarg1) {
90272   Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *) 0 ;
90273
90274   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Toolkit::AccessibilityManager::FocusOvershotDirection) > *)jarg1;
90275   {
90276     try {
90277       delete arg1;
90278     } catch (std::out_of_range& e) {
90279       {
90280         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90281       };
90282     } catch (std::exception& e) {
90283       {
90284         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90285       };
90286     } catch (Dali::DaliException e) {
90287       {
90288         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90289       };
90290     } catch (...) {
90291       {
90292         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90293       };
90294     }
90295   }
90296
90297 }
90298
90299
90300 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Empty(void * jarg1) {
90301   unsigned int jresult ;
90302   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90303   bool result;
90304
90305   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90306   {
90307     try {
90308       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90309     } catch (std::out_of_range& e) {
90310       {
90311         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90312       };
90313     } catch (std::exception& e) {
90314       {
90315         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90316       };
90317     } catch (Dali::DaliException e) {
90318       {
90319         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90320       };
90321     } catch (...) {
90322       {
90323         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90324       };
90325     }
90326   }
90327
90328   jresult = result;
90329   return jresult;
90330 }
90331
90332
90333 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusChangedSignal_GetConnectionCount(void * jarg1) {
90334   unsigned long jresult ;
90335   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90336   std::size_t result;
90337
90338   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90339   {
90340     try {
90341       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,Dali::Actor) > const *)arg1);
90342     } catch (std::out_of_range& e) {
90343       {
90344         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90345       };
90346     } catch (std::exception& e) {
90347       {
90348         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90349       };
90350     } catch (Dali::DaliException e) {
90351       {
90352         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90353       };
90354     } catch (...) {
90355       {
90356         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90357       };
90358     }
90359   }
90360
90361   jresult = (unsigned long)result;
90362   return jresult;
90363 }
90364
90365
90366 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Connect(void * jarg1, void * jarg2) {
90367   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90368   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90369
90370   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90371   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90372   {
90373     try {
90374       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Connect(arg1,arg2);
90375     } catch (std::out_of_range& e) {
90376       {
90377         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90378       };
90379     } catch (std::exception& e) {
90380       {
90381         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90382       };
90383     } catch (Dali::DaliException e) {
90384       {
90385         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90386       };
90387     } catch (...) {
90388       {
90389         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90390       };
90391     }
90392   }
90393
90394 }
90395
90396
90397 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90398   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90399   void (*arg2)(Dali::Actor,Dali::Actor) = (void (*)(Dali::Actor,Dali::Actor)) 0 ;
90400
90401   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90402   arg2 = (void (*)(Dali::Actor,Dali::Actor))jarg2;
90403   {
90404     try {
90405       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Disconnect(arg1,arg2);
90406     } catch (std::out_of_range& e) {
90407       {
90408         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90409       };
90410     } catch (std::exception& e) {
90411       {
90412         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90413       };
90414     } catch (Dali::DaliException e) {
90415       {
90416         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90417       };
90418     } catch (...) {
90419       {
90420         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90421       };
90422     }
90423   }
90424
90425 }
90426
90427
90428 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusChangedSignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
90429   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90430   Dali::Actor arg2 ;
90431   Dali::Actor arg3 ;
90432   Dali::Actor *argp2 ;
90433   Dali::Actor *argp3 ;
90434
90435   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90436   argp2 = (Dali::Actor *)jarg2;
90437   if (!argp2) {
90438     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90439     return ;
90440   }
90441   arg2 = *argp2;
90442   argp3 = (Dali::Actor *)jarg3;
90443   if (!argp3) {
90444     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90445     return ;
90446   }
90447   arg3 = *argp3;
90448   {
90449     try {
90450       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_Dali_Actor_SP__Sg__Emit(arg1,arg2,arg3);
90451     } catch (std::out_of_range& e) {
90452       {
90453         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90454       };
90455     } catch (std::exception& e) {
90456       {
90457         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90458       };
90459     } catch (Dali::DaliException e) {
90460       {
90461         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90462       };
90463     } catch (...) {
90464       {
90465         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90466       };
90467     }
90468   }
90469
90470 }
90471
90472
90473 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusChangedSignal() {
90474   void * jresult ;
90475   Dali::Signal< void (Dali::Actor,Dali::Actor) > *result = 0 ;
90476
90477   {
90478     try {
90479       result = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)new Dali::Signal< void (Dali::Actor,Dali::Actor) >();
90480     } catch (std::out_of_range& e) {
90481       {
90482         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90483       };
90484     } catch (std::exception& e) {
90485       {
90486         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90487       };
90488     } catch (Dali::DaliException e) {
90489       {
90490         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90491       };
90492     } catch (...) {
90493       {
90494         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90495       };
90496     }
90497   }
90498
90499   jresult = (void *)result;
90500   return jresult;
90501 }
90502
90503
90504 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusChangedSignal(void * jarg1) {
90505   Dali::Signal< void (Dali::Actor,Dali::Actor) > *arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *) 0 ;
90506
90507   arg1 = (Dali::Signal< void (Dali::Actor,Dali::Actor) > *)jarg1;
90508   {
90509     try {
90510       delete arg1;
90511     } catch (std::out_of_range& e) {
90512       {
90513         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90514       };
90515     } catch (std::exception& e) {
90516       {
90517         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90518       };
90519     } catch (Dali::DaliException e) {
90520       {
90521         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90522       };
90523     } catch (...) {
90524       {
90525         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90526       };
90527     }
90528   }
90529
90530 }
90531
90532
90533 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Empty(void * jarg1) {
90534   unsigned int jresult ;
90535   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90536   bool result;
90537
90538   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90539   {
90540     try {
90541       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Empty((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90542     } catch (std::out_of_range& e) {
90543       {
90544         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90545       };
90546     } catch (std::exception& e) {
90547       {
90548         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90549       };
90550     } catch (Dali::DaliException e) {
90551       {
90552         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90553       };
90554     } catch (...) {
90555       {
90556         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90557       };
90558     }
90559   }
90560
90561   jresult = result;
90562   return jresult;
90563 }
90564
90565
90566 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_GetConnectionCount(void * jarg1) {
90567   unsigned long jresult ;
90568   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90569   std::size_t result;
90570
90571   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90572   {
90573     try {
90574       result = Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Actor,bool) > const *)arg1);
90575     } catch (std::out_of_range& e) {
90576       {
90577         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90578       };
90579     } catch (std::exception& e) {
90580       {
90581         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90582       };
90583     } catch (Dali::DaliException e) {
90584       {
90585         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90586       };
90587     } catch (...) {
90588       {
90589         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90590       };
90591     }
90592   }
90593
90594   jresult = (unsigned long)result;
90595   return jresult;
90596 }
90597
90598
90599 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Connect(void * jarg1, void * jarg2) {
90600   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90601   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90602
90603   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90604   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90605   {
90606     try {
90607       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Connect(arg1,arg2);
90608     } catch (std::out_of_range& e) {
90609       {
90610         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90611       };
90612     } catch (std::exception& e) {
90613       {
90614         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90615       };
90616     } catch (Dali::DaliException e) {
90617       {
90618         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90619       };
90620     } catch (...) {
90621       {
90622         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90623       };
90624     }
90625   }
90626
90627 }
90628
90629
90630 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90631   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90632   void (*arg2)(Dali::Actor,bool) = (void (*)(Dali::Actor,bool)) 0 ;
90633
90634   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90635   arg2 = (void (*)(Dali::Actor,bool))jarg2;
90636   {
90637     try {
90638       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
90639     } catch (std::out_of_range& e) {
90640       {
90641         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90642       };
90643     } catch (std::exception& e) {
90644       {
90645         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90646       };
90647     } catch (Dali::DaliException e) {
90648       {
90649         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90650       };
90651     } catch (...) {
90652       {
90653         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90654       };
90655     }
90656   }
90657
90658 }
90659
90660
90661 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_FocusGroupChangedSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3) {
90662   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90663   Dali::Actor arg2 ;
90664   bool arg3 ;
90665   Dali::Actor *argp2 ;
90666
90667   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90668   argp2 = (Dali::Actor *)jarg2;
90669   if (!argp2) {
90670     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Actor", 0);
90671     return ;
90672   }
90673   arg2 = *argp2;
90674   arg3 = jarg3 ? true : false;
90675   {
90676     try {
90677       Dali_Signal_Sl_void_Sp_Dali_Actor_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3);
90678     } catch (std::out_of_range& e) {
90679       {
90680         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90681       };
90682     } catch (std::exception& e) {
90683       {
90684         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90685       };
90686     } catch (Dali::DaliException e) {
90687       {
90688         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90689       };
90690     } catch (...) {
90691       {
90692         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90693       };
90694     }
90695   }
90696
90697 }
90698
90699
90700 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_FocusGroupChangedSignal() {
90701   void * jresult ;
90702   Dali::Signal< void (Dali::Actor,bool) > *result = 0 ;
90703
90704   {
90705     try {
90706       result = (Dali::Signal< void (Dali::Actor,bool) > *)new Dali::Signal< void (Dali::Actor,bool) >();
90707     } catch (std::out_of_range& e) {
90708       {
90709         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90710       };
90711     } catch (std::exception& e) {
90712       {
90713         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90714       };
90715     } catch (Dali::DaliException e) {
90716       {
90717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90718       };
90719     } catch (...) {
90720       {
90721         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90722       };
90723     }
90724   }
90725
90726   jresult = (void *)result;
90727   return jresult;
90728 }
90729
90730
90731 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_FocusGroupChangedSignal(void * jarg1) {
90732   Dali::Signal< void (Dali::Actor,bool) > *arg1 = (Dali::Signal< void (Dali::Actor,bool) > *) 0 ;
90733
90734   arg1 = (Dali::Signal< void (Dali::Actor,bool) > *)jarg1;
90735   {
90736     try {
90737       delete arg1;
90738     } catch (std::out_of_range& e) {
90739       {
90740         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90741       };
90742     } catch (std::exception& e) {
90743       {
90744         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90745       };
90746     } catch (Dali::DaliException e) {
90747       {
90748         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90749       };
90750     } catch (...) {
90751       {
90752         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90753       };
90754     }
90755   }
90756
90757 }
90758
90759
90760 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Empty(void * jarg1) {
90761   unsigned int jresult ;
90762   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90763   bool result;
90764
90765   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90766   {
90767     try {
90768       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);
90769     } catch (std::out_of_range& e) {
90770       {
90771         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90772       };
90773     } catch (std::exception& e) {
90774       {
90775         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90776       };
90777     } catch (Dali::DaliException e) {
90778       {
90779         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90780       };
90781     } catch (...) {
90782       {
90783         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90784       };
90785     }
90786   }
90787
90788   jresult = result;
90789   return jresult;
90790 }
90791
90792
90793 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_StyleChangedSignal_GetConnectionCount(void * jarg1) {
90794   unsigned long jresult ;
90795   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90796   std::size_t result;
90797
90798   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90799   {
90800     try {
90801       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);
90802     } catch (std::out_of_range& e) {
90803       {
90804         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90805       };
90806     } catch (std::exception& e) {
90807       {
90808         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90809       };
90810     } catch (Dali::DaliException e) {
90811       {
90812         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90813       };
90814     } catch (...) {
90815       {
90816         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90817       };
90818     }
90819   }
90820
90821   jresult = (unsigned long)result;
90822   return jresult;
90823 }
90824
90825
90826 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Connect(void * jarg1, void * jarg2) {
90827   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90828   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90829
90830   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90831   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90832   {
90833     try {
90834       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Connect(arg1,arg2);
90835     } catch (std::out_of_range& e) {
90836       {
90837         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90838       };
90839     } catch (std::exception& e) {
90840       {
90841         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90842       };
90843     } catch (Dali::DaliException e) {
90844       {
90845         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90846       };
90847     } catch (...) {
90848       {
90849         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90850       };
90851     }
90852   }
90853
90854 }
90855
90856
90857 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Disconnect(void * jarg1, void * jarg2) {
90858   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90859   void (*arg2)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type) = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type)) 0 ;
90860
90861   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90862   arg2 = (void (*)(Dali::Toolkit::StyleManager,Dali::StyleChange::Type))jarg2;
90863   {
90864     try {
90865       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Disconnect(arg1,arg2);
90866     } catch (std::out_of_range& e) {
90867       {
90868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90869       };
90870     } catch (std::exception& e) {
90871       {
90872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90873       };
90874     } catch (Dali::DaliException e) {
90875       {
90876         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90877       };
90878     } catch (...) {
90879       {
90880         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90881       };
90882     }
90883   }
90884
90885 }
90886
90887
90888 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_StyleChangedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
90889   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90890   Dali::Toolkit::StyleManager arg2 ;
90891   Dali::StyleChange::Type arg3 ;
90892   Dali::Toolkit::StyleManager *argp2 ;
90893
90894   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90895   argp2 = (Dali::Toolkit::StyleManager *)jarg2;
90896   if (!argp2) {
90897     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::StyleManager", 0);
90898     return ;
90899   }
90900   arg2 = *argp2;
90901   arg3 = (Dali::StyleChange::Type)jarg3;
90902   {
90903     try {
90904       Dali_Signal_Sl_void_Sp_Dali_Toolkit_StyleManager_Sc_Dali_StyleChange_Type_SP__Sg__Emit(arg1,arg2,arg3);
90905     } catch (std::out_of_range& e) {
90906       {
90907         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90908       };
90909     } catch (std::exception& e) {
90910       {
90911         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90912       };
90913     } catch (Dali::DaliException e) {
90914       {
90915         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90916       };
90917     } catch (...) {
90918       {
90919         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90920       };
90921     }
90922   }
90923
90924 }
90925
90926
90927 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_StyleChangedSignal() {
90928   void * jresult ;
90929   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *result = 0 ;
90930
90931   {
90932     try {
90933       result = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)new Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) >();
90934     } catch (std::out_of_range& e) {
90935       {
90936         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90937       };
90938     } catch (std::exception& e) {
90939       {
90940         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
90941       };
90942     } catch (Dali::DaliException e) {
90943       {
90944         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
90945       };
90946     } catch (...) {
90947       {
90948         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
90949       };
90950     }
90951   }
90952
90953   jresult = (void *)result;
90954   return jresult;
90955 }
90956
90957
90958 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_StyleChangedSignal(void * jarg1) {
90959   Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *) 0 ;
90960
90961   arg1 = (Dali::Signal< void (Dali::Toolkit::StyleManager,Dali::StyleChange::Type) > *)jarg1;
90962   {
90963     try {
90964       delete arg1;
90965     } catch (std::out_of_range& e) {
90966       {
90967         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
90968       };
90969     } catch (std::exception& e) {
90970       {
90971         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
90972       };
90973     } catch (Dali::DaliException e) {
90974       {
90975         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
90976       };
90977     } catch (...) {
90978       {
90979         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
90980       };
90981     }
90982   }
90983
90984 }
90985
90986
90987 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Empty(void * jarg1) {
90988   unsigned int jresult ;
90989   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
90990   bool result;
90991
90992   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
90993   {
90994     try {
90995       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
90996     } catch (std::out_of_range& e) {
90997       {
90998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
90999       };
91000     } catch (std::exception& e) {
91001       {
91002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91003       };
91004     } catch (Dali::DaliException e) {
91005       {
91006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91007       };
91008     } catch (...) {
91009       {
91010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91011       };
91012     }
91013   }
91014
91015   jresult = result;
91016   return jresult;
91017 }
91018
91019
91020 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ButtonSignal_GetConnectionCount(void * jarg1) {
91021   unsigned long jresult ;
91022   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91023   std::size_t result;
91024
91025   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91026   {
91027     try {
91028       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Button) > const *)arg1);
91029     } catch (std::out_of_range& e) {
91030       {
91031         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91032       };
91033     } catch (std::exception& e) {
91034       {
91035         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91036       };
91037     } catch (Dali::DaliException e) {
91038       {
91039         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91040       };
91041     } catch (...) {
91042       {
91043         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91044       };
91045     }
91046   }
91047
91048   jresult = (unsigned long)result;
91049   return jresult;
91050 }
91051
91052
91053 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Connect(void * jarg1, void * jarg2) {
91054   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91055   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91056
91057   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91058   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91059   {
91060     try {
91061       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Connect(arg1,arg2);
91062     } catch (std::out_of_range& e) {
91063       {
91064         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91065       };
91066     } catch (std::exception& e) {
91067       {
91068         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91069       };
91070     } catch (Dali::DaliException e) {
91071       {
91072         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91073       };
91074     } catch (...) {
91075       {
91076         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91077       };
91078     }
91079   }
91080
91081 }
91082
91083
91084 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ButtonSignal_Disconnect(void * jarg1, void * jarg2) {
91085   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91086   bool (*arg2)(Dali::Toolkit::Button) = (bool (*)(Dali::Toolkit::Button)) 0 ;
91087
91088   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91089   arg2 = (bool (*)(Dali::Toolkit::Button))jarg2;
91090   {
91091     try {
91092       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Disconnect(arg1,arg2);
91093     } catch (std::out_of_range& e) {
91094       {
91095         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91096       };
91097     } catch (std::exception& e) {
91098       {
91099         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91100       };
91101     } catch (Dali::DaliException e) {
91102       {
91103         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91104       };
91105     } catch (...) {
91106       {
91107         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91108       };
91109     }
91110   }
91111
91112 }
91113
91114
91115 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ButtonSignal_Emit(void * jarg1, void * jarg2) {
91116   unsigned int jresult ;
91117   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91118   Dali::Toolkit::Button arg2 ;
91119   Dali::Toolkit::Button *argp2 ;
91120   bool result;
91121
91122   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91123   argp2 = (Dali::Toolkit::Button *)jarg2;
91124   if (!argp2) {
91125     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Button", 0);
91126     return 0;
91127   }
91128   arg2 = *argp2;
91129   {
91130     try {
91131       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Button_SP__Sg__Emit(arg1,arg2);
91132     } catch (std::out_of_range& e) {
91133       {
91134         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91135       };
91136     } catch (std::exception& e) {
91137       {
91138         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91139       };
91140     } catch (Dali::DaliException e) {
91141       {
91142         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91143       };
91144     } catch (...) {
91145       {
91146         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91147       };
91148     }
91149   }
91150
91151   jresult = result;
91152   return jresult;
91153 }
91154
91155
91156 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ButtonSignal() {
91157   void * jresult ;
91158   Dali::Signal< bool (Dali::Toolkit::Button) > *result = 0 ;
91159
91160   {
91161     try {
91162       result = (Dali::Signal< bool (Dali::Toolkit::Button) > *)new Dali::Signal< bool (Dali::Toolkit::Button) >();
91163     } catch (std::out_of_range& e) {
91164       {
91165         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91166       };
91167     } catch (std::exception& e) {
91168       {
91169         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91170       };
91171     } catch (Dali::DaliException e) {
91172       {
91173         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91174       };
91175     } catch (...) {
91176       {
91177         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91178       };
91179     }
91180   }
91181
91182   jresult = (void *)result;
91183   return jresult;
91184 }
91185
91186
91187 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ButtonSignal(void * jarg1) {
91188   Dali::Signal< bool (Dali::Toolkit::Button) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *) 0 ;
91189
91190   arg1 = (Dali::Signal< bool (Dali::Toolkit::Button) > *)jarg1;
91191   {
91192     try {
91193       delete arg1;
91194     } catch (std::out_of_range& e) {
91195       {
91196         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91197       };
91198     } catch (std::exception& e) {
91199       {
91200         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91201       };
91202     } catch (Dali::DaliException e) {
91203       {
91204         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91205       };
91206     } catch (...) {
91207       {
91208         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91209       };
91210     }
91211   }
91212
91213 }
91214
91215
91216 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Empty(void * jarg1) {
91217   unsigned int jresult ;
91218   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91219   bool result;
91220
91221   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91222   {
91223     try {
91224       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91225     } catch (std::out_of_range& e) {
91226       {
91227         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91228       };
91229     } catch (std::exception& e) {
91230       {
91231         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91232       };
91233     } catch (Dali::DaliException e) {
91234       {
91235         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91236       };
91237     } catch (...) {
91238       {
91239         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91240       };
91241     }
91242   }
91243
91244   jresult = result;
91245   return jresult;
91246 }
91247
91248
91249 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_GetConnectionCount(void * jarg1) {
91250   unsigned long jresult ;
91251   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91252   std::size_t result;
91253
91254   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91255   {
91256     try {
91257       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > const *)arg1);
91258     } catch (std::out_of_range& e) {
91259       {
91260         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91261       };
91262     } catch (std::exception& e) {
91263       {
91264         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91265       };
91266     } catch (Dali::DaliException e) {
91267       {
91268         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91269       };
91270     } catch (...) {
91271       {
91272         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91273       };
91274     }
91275   }
91276
91277   jresult = (unsigned long)result;
91278   return jresult;
91279 }
91280
91281
91282 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Connect(void * jarg1, void * jarg2) {
91283   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91284   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91285
91286   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91287   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91288   {
91289     try {
91290       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Connect(arg1,arg2);
91291     } catch (std::out_of_range& e) {
91292       {
91293         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91294       };
91295     } catch (std::exception& e) {
91296       {
91297         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91298       };
91299     } catch (Dali::DaliException e) {
91300       {
91301         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91302       };
91303     } catch (...) {
91304       {
91305         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91306       };
91307     }
91308   }
91309
91310 }
91311
91312
91313 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Disconnect(void * jarg1, void * jarg2) {
91314   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91315   void (*arg2)(Dali::Toolkit::GaussianBlurView) = (void (*)(Dali::Toolkit::GaussianBlurView)) 0 ;
91316
91317   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91318   arg2 = (void (*)(Dali::Toolkit::GaussianBlurView))jarg2;
91319   {
91320     try {
91321       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Disconnect(arg1,arg2);
91322     } catch (std::out_of_range& e) {
91323       {
91324         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91325       };
91326     } catch (std::exception& e) {
91327       {
91328         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91329       };
91330     } catch (Dali::DaliException e) {
91331       {
91332         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91333       };
91334     } catch (...) {
91335       {
91336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91337       };
91338     }
91339   }
91340
91341 }
91342
91343
91344 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_GaussianBlurViewSignal_Emit(void * jarg1, void * jarg2) {
91345   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91346   Dali::Toolkit::GaussianBlurView arg2 ;
91347   Dali::Toolkit::GaussianBlurView *argp2 ;
91348
91349   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91350   argp2 = (Dali::Toolkit::GaussianBlurView *)jarg2;
91351   if (!argp2) {
91352     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::GaussianBlurView", 0);
91353     return ;
91354   }
91355   arg2 = *argp2;
91356   {
91357     try {
91358       Dali_Signal_Sl_void_Sp_Dali_Toolkit_GaussianBlurView_SP__Sg__Emit(arg1,arg2);
91359     } catch (std::out_of_range& e) {
91360       {
91361         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91362       };
91363     } catch (std::exception& e) {
91364       {
91365         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91366       };
91367     } catch (Dali::DaliException e) {
91368       {
91369         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91370       };
91371     } catch (...) {
91372       {
91373         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91374       };
91375     }
91376   }
91377
91378 }
91379
91380
91381 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_GaussianBlurViewSignal() {
91382   void * jresult ;
91383   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *result = 0 ;
91384
91385   {
91386     try {
91387       result = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)new Dali::Signal< void (Dali::Toolkit::GaussianBlurView) >();
91388     } catch (std::out_of_range& e) {
91389       {
91390         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91391       };
91392     } catch (std::exception& e) {
91393       {
91394         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91395       };
91396     } catch (Dali::DaliException e) {
91397       {
91398         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91399       };
91400     } catch (...) {
91401       {
91402         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91403       };
91404     }
91405   }
91406
91407   jresult = (void *)result;
91408   return jresult;
91409 }
91410
91411
91412 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_GaussianBlurViewSignal(void * jarg1) {
91413   Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *) 0 ;
91414
91415   arg1 = (Dali::Signal< void (Dali::Toolkit::GaussianBlurView) > *)jarg1;
91416   {
91417     try {
91418       delete arg1;
91419     } catch (std::out_of_range& e) {
91420       {
91421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91422       };
91423     } catch (std::exception& e) {
91424       {
91425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91426       };
91427     } catch (Dali::DaliException e) {
91428       {
91429         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91430       };
91431     } catch (...) {
91432       {
91433         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91434       };
91435     }
91436   }
91437
91438 }
91439
91440
91441 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PageTurnSignal_Empty(void * jarg1) {
91442   unsigned int jresult ;
91443   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91444   bool result;
91445
91446   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91447   {
91448     try {
91449       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);
91450     } catch (std::out_of_range& e) {
91451       {
91452         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91453       };
91454     } catch (std::exception& e) {
91455       {
91456         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91457       };
91458     } catch (Dali::DaliException e) {
91459       {
91460         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91461       };
91462     } catch (...) {
91463       {
91464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91465       };
91466     }
91467   }
91468
91469   jresult = result;
91470   return jresult;
91471 }
91472
91473
91474 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PageTurnSignal_GetConnectionCount(void * jarg1) {
91475   unsigned long jresult ;
91476   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91477   std::size_t result;
91478
91479   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91480   {
91481     try {
91482       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);
91483     } catch (std::out_of_range& e) {
91484       {
91485         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91486       };
91487     } catch (std::exception& e) {
91488       {
91489         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91490       };
91491     } catch (Dali::DaliException e) {
91492       {
91493         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91494       };
91495     } catch (...) {
91496       {
91497         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91498       };
91499     }
91500   }
91501
91502   jresult = (unsigned long)result;
91503   return jresult;
91504 }
91505
91506
91507 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Connect(void * jarg1, void * jarg2) {
91508   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91509   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91510
91511   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91512   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91513   {
91514     try {
91515       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Connect(arg1,arg2);
91516     } catch (std::out_of_range& e) {
91517       {
91518         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91519       };
91520     } catch (std::exception& e) {
91521       {
91522         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91523       };
91524     } catch (Dali::DaliException e) {
91525       {
91526         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91527       };
91528     } catch (...) {
91529       {
91530         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91531       };
91532     }
91533   }
91534
91535 }
91536
91537
91538 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Disconnect(void * jarg1, void * jarg2) {
91539   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91540   void (*arg2)(Dali::Toolkit::PageTurnView,unsigned int,bool) = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool)) 0 ;
91541
91542   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91543   arg2 = (void (*)(Dali::Toolkit::PageTurnView,unsigned int,bool))jarg2;
91544   {
91545     try {
91546       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Disconnect(arg1,arg2);
91547     } catch (std::out_of_range& e) {
91548       {
91549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91550       };
91551     } catch (std::exception& e) {
91552       {
91553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91554       };
91555     } catch (Dali::DaliException e) {
91556       {
91557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91558       };
91559     } catch (...) {
91560       {
91561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91562       };
91563     }
91564   }
91565
91566 }
91567
91568
91569 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PageTurnSignal_Emit(void * jarg1, void * jarg2, unsigned int jarg3, unsigned int jarg4) {
91570   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91571   Dali::Toolkit::PageTurnView arg2 ;
91572   unsigned int arg3 ;
91573   bool arg4 ;
91574   Dali::Toolkit::PageTurnView *argp2 ;
91575
91576   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91577   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91578   if (!argp2) {
91579     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91580     return ;
91581   }
91582   arg2 = *argp2;
91583   arg3 = (unsigned int)jarg3;
91584   arg4 = jarg4 ? true : false;
91585   {
91586     try {
91587       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_Sc_unsigned_SS_int_Sc_bool_SP__Sg__Emit(arg1,arg2,arg3,arg4);
91588     } catch (std::out_of_range& e) {
91589       {
91590         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91591       };
91592     } catch (std::exception& e) {
91593       {
91594         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91595       };
91596     } catch (Dali::DaliException e) {
91597       {
91598         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91599       };
91600     } catch (...) {
91601       {
91602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91603       };
91604     }
91605   }
91606
91607 }
91608
91609
91610 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PageTurnSignal() {
91611   void * jresult ;
91612   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *result = 0 ;
91613
91614   {
91615     try {
91616       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) >();
91617     } catch (std::out_of_range& e) {
91618       {
91619         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91620       };
91621     } catch (std::exception& e) {
91622       {
91623         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91624       };
91625     } catch (Dali::DaliException e) {
91626       {
91627         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91628       };
91629     } catch (...) {
91630       {
91631         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91632       };
91633     }
91634   }
91635
91636   jresult = (void *)result;
91637   return jresult;
91638 }
91639
91640
91641 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PageTurnSignal(void * jarg1) {
91642   Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *) 0 ;
91643
91644   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView,unsigned int,bool) > *)jarg1;
91645   {
91646     try {
91647       delete arg1;
91648     } catch (std::out_of_range& e) {
91649       {
91650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91651       };
91652     } catch (std::exception& e) {
91653       {
91654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91655       };
91656     } catch (Dali::DaliException e) {
91657       {
91658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91659       };
91660     } catch (...) {
91661       {
91662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91663       };
91664     }
91665   }
91666
91667 }
91668
91669
91670 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PagePanSignal_Empty(void * jarg1) {
91671   unsigned int jresult ;
91672   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91673   bool result;
91674
91675   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91676   {
91677     try {
91678       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91679     } catch (std::out_of_range& e) {
91680       {
91681         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91682       };
91683     } catch (std::exception& e) {
91684       {
91685         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91686       };
91687     } catch (Dali::DaliException e) {
91688       {
91689         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91690       };
91691     } catch (...) {
91692       {
91693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91694       };
91695     }
91696   }
91697
91698   jresult = result;
91699   return jresult;
91700 }
91701
91702
91703 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_PagePanSignal_GetConnectionCount(void * jarg1) {
91704   unsigned long jresult ;
91705   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91706   std::size_t result;
91707
91708   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91709   {
91710     try {
91711       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::PageTurnView) > const *)arg1);
91712     } catch (std::out_of_range& e) {
91713       {
91714         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91715       };
91716     } catch (std::exception& e) {
91717       {
91718         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91719       };
91720     } catch (Dali::DaliException e) {
91721       {
91722         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91723       };
91724     } catch (...) {
91725       {
91726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91727       };
91728     }
91729   }
91730
91731   jresult = (unsigned long)result;
91732   return jresult;
91733 }
91734
91735
91736 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Connect(void * jarg1, void * jarg2) {
91737   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91738   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91739
91740   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91741   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91742   {
91743     try {
91744       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Connect(arg1,arg2);
91745     } catch (std::out_of_range& e) {
91746       {
91747         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91748       };
91749     } catch (std::exception& e) {
91750       {
91751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91752       };
91753     } catch (Dali::DaliException e) {
91754       {
91755         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91756       };
91757     } catch (...) {
91758       {
91759         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91760       };
91761     }
91762   }
91763
91764 }
91765
91766
91767 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Disconnect(void * jarg1, void * jarg2) {
91768   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91769   void (*arg2)(Dali::Toolkit::PageTurnView) = (void (*)(Dali::Toolkit::PageTurnView)) 0 ;
91770
91771   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91772   arg2 = (void (*)(Dali::Toolkit::PageTurnView))jarg2;
91773   {
91774     try {
91775       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Disconnect(arg1,arg2);
91776     } catch (std::out_of_range& e) {
91777       {
91778         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91779       };
91780     } catch (std::exception& e) {
91781       {
91782         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91783       };
91784     } catch (Dali::DaliException e) {
91785       {
91786         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91787       };
91788     } catch (...) {
91789       {
91790         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91791       };
91792     }
91793   }
91794
91795 }
91796
91797
91798 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PagePanSignal_Emit(void * jarg1, void * jarg2) {
91799   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91800   Dali::Toolkit::PageTurnView arg2 ;
91801   Dali::Toolkit::PageTurnView *argp2 ;
91802
91803   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91804   argp2 = (Dali::Toolkit::PageTurnView *)jarg2;
91805   if (!argp2) {
91806     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::PageTurnView", 0);
91807     return ;
91808   }
91809   arg2 = *argp2;
91810   {
91811     try {
91812       Dali_Signal_Sl_void_Sp_Dali_Toolkit_PageTurnView_SP__Sg__Emit(arg1,arg2);
91813     } catch (std::out_of_range& e) {
91814       {
91815         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91816       };
91817     } catch (std::exception& e) {
91818       {
91819         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91820       };
91821     } catch (Dali::DaliException e) {
91822       {
91823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91824       };
91825     } catch (...) {
91826       {
91827         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91828       };
91829     }
91830   }
91831
91832 }
91833
91834
91835 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PagePanSignal() {
91836   void * jresult ;
91837   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *result = 0 ;
91838
91839   {
91840     try {
91841       result = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)new Dali::Signal< void (Dali::Toolkit::PageTurnView) >();
91842     } catch (std::out_of_range& e) {
91843       {
91844         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91845       };
91846     } catch (std::exception& e) {
91847       {
91848         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91849       };
91850     } catch (Dali::DaliException e) {
91851       {
91852         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91853       };
91854     } catch (...) {
91855       {
91856         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91857       };
91858     }
91859   }
91860
91861   jresult = (void *)result;
91862   return jresult;
91863 }
91864
91865
91866 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PagePanSignal(void * jarg1) {
91867   Dali::Signal< void (Dali::Toolkit::PageTurnView) > *arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *) 0 ;
91868
91869   arg1 = (Dali::Signal< void (Dali::Toolkit::PageTurnView) > *)jarg1;
91870   {
91871     try {
91872       delete arg1;
91873     } catch (std::out_of_range& e) {
91874       {
91875         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91876       };
91877     } catch (std::exception& e) {
91878       {
91879         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91880       };
91881     } catch (Dali::DaliException e) {
91882       {
91883         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91884       };
91885     } catch (...) {
91886       {
91887         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91888       };
91889     }
91890   }
91891
91892 }
91893
91894
91895 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Empty(void * jarg1) {
91896   unsigned int jresult ;
91897   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91898   bool result;
91899
91900   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91901   {
91902     try {
91903       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);
91904     } catch (std::out_of_range& e) {
91905       {
91906         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91907       };
91908     } catch (std::exception& e) {
91909       {
91910         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91911       };
91912     } catch (Dali::DaliException e) {
91913       {
91914         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91915       };
91916     } catch (...) {
91917       {
91918         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91919       };
91920     }
91921   }
91922
91923   jresult = result;
91924   return jresult;
91925 }
91926
91927
91928 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_GetConnectionCount(void * jarg1) {
91929   unsigned long jresult ;
91930   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91931   std::size_t result;
91932
91933   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91934   {
91935     try {
91936       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);
91937     } catch (std::out_of_range& e) {
91938       {
91939         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
91940       };
91941     } catch (std::exception& e) {
91942       {
91943         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
91944       };
91945     } catch (Dali::DaliException e) {
91946       {
91947         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
91948       };
91949     } catch (...) {
91950       {
91951         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
91952       };
91953     }
91954   }
91955
91956   jresult = (unsigned long)result;
91957   return jresult;
91958 }
91959
91960
91961 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Connect(void * jarg1, void * jarg2) {
91962   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91963   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91964
91965   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91966   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91967   {
91968     try {
91969       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Connect(arg1,arg2);
91970     } catch (std::out_of_range& e) {
91971       {
91972         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
91973       };
91974     } catch (std::exception& e) {
91975       {
91976         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
91977       };
91978     } catch (Dali::DaliException e) {
91979       {
91980         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
91981       };
91982     } catch (...) {
91983       {
91984         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
91985       };
91986     }
91987   }
91988
91989 }
91990
91991
91992 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
91993   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
91994   void (*arg2)(Dali::Toolkit::ProgressBar,float,float) = (void (*)(Dali::Toolkit::ProgressBar,float,float)) 0 ;
91995
91996   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
91997   arg2 = (void (*)(Dali::Toolkit::ProgressBar,float,float))jarg2;
91998   {
91999     try {
92000       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Disconnect(arg1,arg2);
92001     } catch (std::out_of_range& e) {
92002       {
92003         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92004       };
92005     } catch (std::exception& e) {
92006       {
92007         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92008       };
92009     } catch (Dali::DaliException e) {
92010       {
92011         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92012       };
92013     } catch (...) {
92014       {
92015         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92016       };
92017     }
92018   }
92019
92020 }
92021
92022
92023 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ProgressBarValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3, float jarg4) {
92024   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92025   Dali::Toolkit::ProgressBar arg2 ;
92026   float arg3 ;
92027   float arg4 ;
92028   Dali::Toolkit::ProgressBar *argp2 ;
92029
92030   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92031   argp2 = (Dali::Toolkit::ProgressBar *)jarg2;
92032   if (!argp2) {
92033     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::ProgressBar", 0);
92034     return ;
92035   }
92036   arg2 = *argp2;
92037   arg3 = (float)jarg3;
92038   arg4 = (float)jarg4;
92039   {
92040     try {
92041       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ProgressBar_Sc_float_Sc_float_SP__Sg__Emit(arg1,arg2,arg3,arg4);
92042     } catch (std::out_of_range& e) {
92043       {
92044         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92045       };
92046     } catch (std::exception& e) {
92047       {
92048         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92049       };
92050     } catch (Dali::DaliException e) {
92051       {
92052         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92053       };
92054     } catch (...) {
92055       {
92056         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92057       };
92058     }
92059   }
92060
92061 }
92062
92063
92064 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ProgressBarValueChangedSignal() {
92065   void * jresult ;
92066   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *result = 0 ;
92067
92068   {
92069     try {
92070       result = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)new Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) >();
92071     } catch (std::out_of_range& e) {
92072       {
92073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92074       };
92075     } catch (std::exception& e) {
92076       {
92077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92078       };
92079     } catch (Dali::DaliException e) {
92080       {
92081         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92082       };
92083     } catch (...) {
92084       {
92085         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92086       };
92087     }
92088   }
92089
92090   jresult = (void *)result;
92091   return jresult;
92092 }
92093
92094
92095 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ProgressBarValueChangedSignal(void * jarg1) {
92096   Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *) 0 ;
92097
92098   arg1 = (Dali::Signal< void (Dali::Toolkit::ProgressBar,float,float) > *)jarg1;
92099   {
92100     try {
92101       delete arg1;
92102     } catch (std::out_of_range& e) {
92103       {
92104         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92105       };
92106     } catch (std::exception& e) {
92107       {
92108         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92109       };
92110     } catch (Dali::DaliException e) {
92111       {
92112         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92113       };
92114     } catch (...) {
92115       {
92116         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92117       };
92118     }
92119   }
92120
92121 }
92122
92123
92124 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Empty(void * jarg1) {
92125   unsigned int jresult ;
92126   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92127   bool result;
92128
92129   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92130   {
92131     try {
92132       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);
92133     } catch (std::out_of_range& e) {
92134       {
92135         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92136       };
92137     } catch (std::exception& e) {
92138       {
92139         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92140       };
92141     } catch (Dali::DaliException e) {
92142       {
92143         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92144       };
92145     } catch (...) {
92146       {
92147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92148       };
92149     }
92150   }
92151
92152   jresult = result;
92153   return jresult;
92154 }
92155
92156
92157 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_GetConnectionCount(void * jarg1) {
92158   unsigned long jresult ;
92159   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92160   std::size_t result;
92161
92162   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92163   {
92164     try {
92165       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);
92166     } catch (std::out_of_range& e) {
92167       {
92168         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92169       };
92170     } catch (std::exception& e) {
92171       {
92172         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92173       };
92174     } catch (Dali::DaliException e) {
92175       {
92176         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92177       };
92178     } catch (...) {
92179       {
92180         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92181       };
92182     }
92183   }
92184
92185   jresult = (unsigned long)result;
92186   return jresult;
92187 }
92188
92189
92190 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Connect(void * jarg1, void * jarg2) {
92191   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92192   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92193
92194   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92195   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92196   {
92197     try {
92198       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92199     } catch (std::out_of_range& e) {
92200       {
92201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92202       };
92203     } catch (std::exception& e) {
92204       {
92205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92206       };
92207     } catch (Dali::DaliException e) {
92208       {
92209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92210       };
92211     } catch (...) {
92212       {
92213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92214       };
92215     }
92216   }
92217
92218 }
92219
92220
92221 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Disconnect(void * jarg1, void * jarg2) {
92222   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92223   void (*arg2)(Dali::Toolkit::ScrollView::SnapEvent const &) = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &)) 0 ;
92224
92225   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92226   arg2 = (void (*)(Dali::Toolkit::ScrollView::SnapEvent const &))jarg2;
92227   {
92228     try {
92229       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92230     } catch (std::out_of_range& e) {
92231       {
92232         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92233       };
92234     } catch (std::exception& e) {
92235       {
92236         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92237       };
92238     } catch (Dali::DaliException e) {
92239       {
92240         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92241       };
92242     } catch (...) {
92243       {
92244         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92245       };
92246     }
92247   }
92248
92249 }
92250
92251
92252 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollViewSnapStartedSignal_Emit(void * jarg1, void * jarg2) {
92253   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92254   Dali::Toolkit::ScrollView::SnapEvent *arg2 = 0 ;
92255
92256   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92257   arg2 = (Dali::Toolkit::ScrollView::SnapEvent *)jarg2;
92258   if (!arg2) {
92259     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ScrollView::SnapEvent const & type is null", 0);
92260     return ;
92261   }
92262   {
92263     try {
92264       Dali_Signal_Sl_void_Sp_Dali_Toolkit_ScrollView_SnapEvent_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Toolkit::ScrollView::SnapEvent const &)*arg2);
92265     } catch (std::out_of_range& e) {
92266       {
92267         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92268       };
92269     } catch (std::exception& e) {
92270       {
92271         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92272       };
92273     } catch (Dali::DaliException e) {
92274       {
92275         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92276       };
92277     } catch (...) {
92278       {
92279         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92280       };
92281     }
92282   }
92283
92284 }
92285
92286
92287 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollViewSnapStartedSignal() {
92288   void * jresult ;
92289   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *result = 0 ;
92290
92291   {
92292     try {
92293       result = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)new Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) >();
92294     } catch (std::out_of_range& e) {
92295       {
92296         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92297       };
92298     } catch (std::exception& e) {
92299       {
92300         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92301       };
92302     } catch (Dali::DaliException e) {
92303       {
92304         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92305       };
92306     } catch (...) {
92307       {
92308         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92309       };
92310     }
92311   }
92312
92313   jresult = (void *)result;
92314   return jresult;
92315 }
92316
92317
92318 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollViewSnapStartedSignal(void * jarg1) {
92319   Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *) 0 ;
92320
92321   arg1 = (Dali::Signal< void (Dali::Toolkit::ScrollView::SnapEvent const &) > *)jarg1;
92322   {
92323     try {
92324       delete arg1;
92325     } catch (std::out_of_range& e) {
92326       {
92327         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92328       };
92329     } catch (std::exception& e) {
92330       {
92331         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92332       };
92333     } catch (Dali::DaliException e) {
92334       {
92335         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92336       };
92337     } catch (...) {
92338       {
92339         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92340       };
92341     }
92342   }
92343
92344 }
92345
92346
92347 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ScrollableSignal_Empty(void * jarg1) {
92348   unsigned int jresult ;
92349   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92350   bool result;
92351
92352   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92353   {
92354     try {
92355       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92356     } catch (std::out_of_range& e) {
92357       {
92358         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92359       };
92360     } catch (std::exception& e) {
92361       {
92362         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92363       };
92364     } catch (Dali::DaliException e) {
92365       {
92366         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92367       };
92368     } catch (...) {
92369       {
92370         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92371       };
92372     }
92373   }
92374
92375   jresult = result;
92376   return jresult;
92377 }
92378
92379
92380 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ScrollableSignal_GetConnectionCount(void * jarg1) {
92381   unsigned long jresult ;
92382   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92383   std::size_t result;
92384
92385   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92386   {
92387     try {
92388       result = Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Vector2 const &) > const *)arg1);
92389     } catch (std::out_of_range& e) {
92390       {
92391         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92392       };
92393     } catch (std::exception& e) {
92394       {
92395         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92396       };
92397     } catch (Dali::DaliException e) {
92398       {
92399         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92400       };
92401     } catch (...) {
92402       {
92403         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92404       };
92405     }
92406   }
92407
92408   jresult = (unsigned long)result;
92409   return jresult;
92410 }
92411
92412
92413 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Connect(void * jarg1, void * jarg2) {
92414   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92415   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92416
92417   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92418   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92419   {
92420     try {
92421       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92422     } catch (std::out_of_range& e) {
92423       {
92424         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92425       };
92426     } catch (std::exception& e) {
92427       {
92428         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92429       };
92430     } catch (Dali::DaliException e) {
92431       {
92432         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92433       };
92434     } catch (...) {
92435       {
92436         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92437       };
92438     }
92439   }
92440
92441 }
92442
92443
92444 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Disconnect(void * jarg1, void * jarg2) {
92445   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92446   void (*arg2)(Dali::Vector2 const &) = (void (*)(Dali::Vector2 const &)) 0 ;
92447
92448   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92449   arg2 = (void (*)(Dali::Vector2 const &))jarg2;
92450   {
92451     try {
92452       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92453     } catch (std::out_of_range& e) {
92454       {
92455         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92456       };
92457     } catch (std::exception& e) {
92458       {
92459         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92460       };
92461     } catch (Dali::DaliException e) {
92462       {
92463         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92464       };
92465     } catch (...) {
92466       {
92467         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92468       };
92469     }
92470   }
92471
92472 }
92473
92474
92475 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ScrollableSignal_Emit(void * jarg1, void * jarg2) {
92476   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92477   Dali::Vector2 *arg2 = 0 ;
92478
92479   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92480   arg2 = (Dali::Vector2 *)jarg2;
92481   if (!arg2) {
92482     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Vector2 const & type is null", 0);
92483     return ;
92484   }
92485   {
92486     try {
92487       Dali_Signal_Sl_void_Sp_Dali_Vector2_SS_const_SA__SP__Sg__Emit(arg1,(Dali::Vector2 const &)*arg2);
92488     } catch (std::out_of_range& e) {
92489       {
92490         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92491       };
92492     } catch (std::exception& e) {
92493       {
92494         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92495       };
92496     } catch (Dali::DaliException e) {
92497       {
92498         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92499       };
92500     } catch (...) {
92501       {
92502         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92503       };
92504     }
92505   }
92506
92507 }
92508
92509
92510 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ScrollableSignal() {
92511   void * jresult ;
92512   Dali::Signal< void (Dali::Vector2 const &) > *result = 0 ;
92513
92514   {
92515     try {
92516       result = (Dali::Signal< void (Dali::Vector2 const &) > *)new Dali::Signal< void (Dali::Vector2 const &) >();
92517     } catch (std::out_of_range& e) {
92518       {
92519         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92520       };
92521     } catch (std::exception& e) {
92522       {
92523         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92524       };
92525     } catch (Dali::DaliException e) {
92526       {
92527         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92528       };
92529     } catch (...) {
92530       {
92531         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92532       };
92533     }
92534   }
92535
92536   jresult = (void *)result;
92537   return jresult;
92538 }
92539
92540
92541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ScrollableSignal(void * jarg1) {
92542   Dali::Signal< void (Dali::Vector2 const &) > *arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *) 0 ;
92543
92544   arg1 = (Dali::Signal< void (Dali::Vector2 const &) > *)jarg1;
92545   {
92546     try {
92547       delete arg1;
92548     } catch (std::out_of_range& e) {
92549       {
92550         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92551       };
92552     } catch (std::exception& e) {
92553       {
92554         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92555       };
92556     } catch (Dali::DaliException e) {
92557       {
92558         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92559       };
92560     } catch (...) {
92561       {
92562         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92563       };
92564     }
92565   }
92566
92567 }
92568
92569
92570
92571 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Empty(void * jarg1) {
92572   unsigned int jresult ;
92573   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92574   bool result;
92575
92576   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92577   {
92578     try {
92579       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);
92580     } catch (std::out_of_range& e) {
92581       {
92582         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92583       };
92584     } catch (std::exception& e) {
92585       {
92586         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92587       };
92588     } catch (Dali::DaliException e) {
92589       {
92590         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92591       };
92592     } catch (...) {
92593       {
92594         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92595       };
92596     }
92597   }
92598
92599   jresult = result;
92600   return jresult;
92601 }
92602
92603
92604 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ControlKeySignal_GetConnectionCount(void * jarg1) {
92605   unsigned long jresult ;
92606   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92607   std::size_t result;
92608
92609   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92610   {
92611     try {
92612       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);
92613     } catch (std::out_of_range& e) {
92614       {
92615         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92616       };
92617     } catch (std::exception& e) {
92618       {
92619         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92620       };
92621     } catch (Dali::DaliException e) {
92622       {
92623         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92624       };
92625     } catch (...) {
92626       {
92627         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92628       };
92629     }
92630   }
92631
92632   jresult = (unsigned long)result;
92633   return jresult;
92634 }
92635
92636
92637 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Connect(void * jarg1, void * jarg2) {
92638   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92639   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92640
92641   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92642   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92643   {
92644     try {
92645       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Connect(arg1,arg2);
92646     } catch (std::out_of_range& e) {
92647       {
92648         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92649       };
92650     } catch (std::exception& e) {
92651       {
92652         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92653       };
92654     } catch (Dali::DaliException e) {
92655       {
92656         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92657       };
92658     } catch (...) {
92659       {
92660         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92661       };
92662     }
92663   }
92664
92665 }
92666
92667
92668 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ControlKeySignal_Disconnect(void * jarg1, void * jarg2) {
92669   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92670   bool (*arg2)(Dali::Toolkit::Control,Dali::KeyEvent const &) = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &)) 0 ;
92671
92672   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92673   arg2 = (bool (*)(Dali::Toolkit::Control,Dali::KeyEvent const &))jarg2;
92674   {
92675     try {
92676       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Control_Sc_Dali_KeyEvent_SS_const_SA__SP__Sg__Disconnect(arg1,arg2);
92677     } catch (std::out_of_range& e) {
92678       {
92679         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92680       };
92681     } catch (std::exception& e) {
92682       {
92683         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92684       };
92685     } catch (Dali::DaliException e) {
92686       {
92687         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92688       };
92689     } catch (...) {
92690       {
92691         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92692       };
92693     }
92694   }
92695
92696 }
92697
92698
92699 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ControlKeySignal_Emit(void * jarg1, void * jarg2, void * jarg3) {
92700   unsigned int jresult ;
92701   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92702   Dali::Toolkit::Control arg2 ;
92703   Dali::KeyEvent *arg3 = 0 ;
92704   Dali::Toolkit::Control *argp2 ;
92705   bool result;
92706
92707   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92708   argp2 = (Dali::Toolkit::Control *)jarg2;
92709   if (!argp2) {
92710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92711     return 0;
92712   }
92713   arg2 = *argp2;
92714   arg3 = (Dali::KeyEvent *)jarg3;
92715   if (!arg3) {
92716     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::KeyEvent const & type is null", 0);
92717     return 0;
92718   }
92719   {
92720     try {
92721       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);
92722     } catch (std::out_of_range& e) {
92723       {
92724         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92725       };
92726     } catch (std::exception& e) {
92727       {
92728         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92729       };
92730     } catch (Dali::DaliException e) {
92731       {
92732         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92733       };
92734     } catch (...) {
92735       {
92736         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92737       };
92738     }
92739   }
92740
92741   jresult = result;
92742   return jresult;
92743 }
92744
92745
92746 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ControlKeySignal() {
92747   void * jresult ;
92748   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *result = 0 ;
92749
92750   {
92751     try {
92752       result = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)new Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) >();
92753     } catch (std::out_of_range& e) {
92754       {
92755         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92756       };
92757     } catch (std::exception& e) {
92758       {
92759         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92760       };
92761     } catch (Dali::DaliException e) {
92762       {
92763         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92764       };
92765     } catch (...) {
92766       {
92767         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92768       };
92769     }
92770   }
92771
92772   jresult = (void *)result;
92773   return jresult;
92774 }
92775
92776
92777 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ControlKeySignal(void * jarg1) {
92778   Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *) 0 ;
92779
92780   arg1 = (Dali::Signal< bool (Dali::Toolkit::Control,Dali::KeyEvent const &) > *)jarg1;
92781   {
92782     try {
92783       delete arg1;
92784     } catch (std::out_of_range& e) {
92785       {
92786         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92787       };
92788     } catch (std::exception& e) {
92789       {
92790         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92791       };
92792     } catch (Dali::DaliException e) {
92793       {
92794         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92795       };
92796     } catch (...) {
92797       {
92798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92799       };
92800     }
92801   }
92802
92803 }
92804
92805
92806 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Empty(void * jarg1) {
92807   unsigned int jresult ;
92808   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92809   bool result;
92810
92811   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92812   {
92813     try {
92814       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92815     } catch (std::out_of_range& e) {
92816       {
92817         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92818       };
92819     } catch (std::exception& e) {
92820       {
92821         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92822       };
92823     } catch (Dali::DaliException e) {
92824       {
92825         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92826       };
92827     } catch (...) {
92828       {
92829         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92830       };
92831     }
92832   }
92833
92834   jresult = result;
92835   return jresult;
92836 }
92837
92838
92839 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_GetConnectionCount(void * jarg1) {
92840   unsigned long jresult ;
92841   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92842   std::size_t result;
92843
92844   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92845   {
92846     try {
92847       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
92848     } catch (std::out_of_range& e) {
92849       {
92850         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92851       };
92852     } catch (std::exception& e) {
92853       {
92854         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92855       };
92856     } catch (Dali::DaliException e) {
92857       {
92858         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92859       };
92860     } catch (...) {
92861       {
92862         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92863       };
92864     }
92865   }
92866
92867   jresult = (unsigned long)result;
92868   return jresult;
92869 }
92870
92871
92872 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Connect(void * jarg1, void * jarg2) {
92873   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92874   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92875
92876   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92877   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92878   {
92879     try {
92880       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
92881     } catch (std::out_of_range& e) {
92882       {
92883         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92884       };
92885     } catch (std::exception& e) {
92886       {
92887         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92888       };
92889     } catch (Dali::DaliException e) {
92890       {
92891         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92892       };
92893     } catch (...) {
92894       {
92895         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92896       };
92897     }
92898   }
92899
92900 }
92901
92902
92903 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Disconnect(void * jarg1, void * jarg2) {
92904   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92905   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
92906
92907   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92908   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
92909   {
92910     try {
92911       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
92912     } catch (std::out_of_range& e) {
92913       {
92914         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
92915       };
92916     } catch (std::exception& e) {
92917       {
92918         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
92919       };
92920     } catch (Dali::DaliException e) {
92921       {
92922         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
92923       };
92924     } catch (...) {
92925       {
92926         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
92927       };
92928     }
92929   }
92930
92931 }
92932
92933
92934 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_KeyInputFocusSignal_Emit(void * jarg1, void * jarg2) {
92935   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
92936   Dali::Toolkit::Control arg2 ;
92937   Dali::Toolkit::Control *argp2 ;
92938
92939   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
92940   argp2 = (Dali::Toolkit::Control *)jarg2;
92941   if (!argp2) {
92942     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
92943     return ;
92944   }
92945   arg2 = *argp2;
92946   {
92947     try {
92948       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(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_new_KeyInputFocusSignal() {
92972   void * jresult ;
92973   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
92974
92975   {
92976     try {
92977       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
92978     } catch (std::out_of_range& e) {
92979       {
92980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
92981       };
92982     } catch (std::exception& e) {
92983       {
92984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
92985       };
92986     } catch (Dali::DaliException e) {
92987       {
92988         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
92989       };
92990     } catch (...) {
92991       {
92992         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
92993       };
92994     }
92995   }
92996
92997   jresult = (void *)result;
92998   return jresult;
92999 }
93000
93001
93002 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_KeyInputFocusSignal(void * jarg1) {
93003   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
93004
93005   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
93006   {
93007     try {
93008       delete arg1;
93009     } catch (std::out_of_range& e) {
93010       {
93011         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93012       };
93013     } catch (std::exception& e) {
93014       {
93015         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93016       };
93017     } catch (Dali::DaliException e) {
93018       {
93019         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93020       };
93021     } catch (...) {
93022       {
93023         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93024       };
93025     }
93026   }
93027
93028 }
93029
93030
93031 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_VideoViewSignal_Empty(void * jarg1) {
93032   unsigned int jresult ;
93033   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93034   bool result;
93035
93036   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93037   {
93038     try {
93039       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93040     } catch (std::out_of_range& e) {
93041       {
93042         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93043       };
93044     } catch (std::exception& e) {
93045       {
93046         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93047       };
93048     } catch (Dali::DaliException e) {
93049       {
93050         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93051       };
93052     } catch (...) {
93053       {
93054         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93055       };
93056     }
93057   }
93058
93059   jresult = result;
93060   return jresult;
93061 }
93062
93063
93064 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_VideoViewSignal_GetConnectionCount(void * jarg1) {
93065   unsigned long jresult ;
93066   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93067   std::size_t result;
93068
93069   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93070   {
93071     try {
93072       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::VideoView &) > const *)arg1);
93073     } catch (std::out_of_range& e) {
93074       {
93075         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93076       };
93077     } catch (std::exception& e) {
93078       {
93079         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93080       };
93081     } catch (Dali::DaliException e) {
93082       {
93083         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93084       };
93085     } catch (...) {
93086       {
93087         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93088       };
93089     }
93090   }
93091
93092   jresult = (unsigned long)result;
93093   return jresult;
93094 }
93095
93096
93097 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Connect(void * jarg1, void * jarg2) {
93098   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93099   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93100
93101   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93102   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93103   {
93104     try {
93105       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Connect(arg1,arg2);
93106     } catch (std::out_of_range& e) {
93107       {
93108         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93109       };
93110     } catch (std::exception& e) {
93111       {
93112         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93113       };
93114     } catch (Dali::DaliException e) {
93115       {
93116         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93117       };
93118     } catch (...) {
93119       {
93120         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93121       };
93122     }
93123   }
93124
93125 }
93126
93127
93128 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Disconnect(void * jarg1, void * jarg2) {
93129   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93130   void (*arg2)(Dali::Toolkit::VideoView &) = (void (*)(Dali::Toolkit::VideoView &)) 0 ;
93131
93132   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93133   arg2 = (void (*)(Dali::Toolkit::VideoView &))jarg2;
93134   {
93135     try {
93136       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Disconnect(arg1,arg2);
93137     } catch (std::out_of_range& e) {
93138       {
93139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93140       };
93141     } catch (std::exception& e) {
93142       {
93143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93144       };
93145     } catch (Dali::DaliException e) {
93146       {
93147         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93148       };
93149     } catch (...) {
93150       {
93151         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93152       };
93153     }
93154   }
93155
93156 }
93157
93158
93159 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_VideoViewSignal_Emit(void * jarg1, void * jarg2) {
93160   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93161   Dali::Toolkit::VideoView *arg2 = 0 ;
93162
93163   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93164   arg2 = (Dali::Toolkit::VideoView *)jarg2;
93165   if (!arg2) {
93166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::VideoView & type is null", 0);
93167     return ;
93168   }
93169   {
93170     try {
93171       Dali_Signal_Sl_void_Sp_Dali_Toolkit_VideoView_SA__SP__Sg__Emit(arg1,*arg2);
93172     } catch (std::out_of_range& e) {
93173       {
93174         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93175       };
93176     } catch (std::exception& e) {
93177       {
93178         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93179       };
93180     } catch (Dali::DaliException e) {
93181       {
93182         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93183       };
93184     } catch (...) {
93185       {
93186         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93187       };
93188     }
93189   }
93190
93191 }
93192
93193
93194 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_VideoViewSignal() {
93195   void * jresult ;
93196   Dali::Signal< void (Dali::Toolkit::VideoView &) > *result = 0 ;
93197
93198   {
93199     try {
93200       result = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)new Dali::Signal< void (Dali::Toolkit::VideoView &) >();
93201     } catch (std::out_of_range& e) {
93202       {
93203         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93204       };
93205     } catch (std::exception& e) {
93206       {
93207         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93208       };
93209     } catch (Dali::DaliException e) {
93210       {
93211         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93212       };
93213     } catch (...) {
93214       {
93215         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93216       };
93217     }
93218   }
93219
93220   jresult = (void *)result;
93221   return jresult;
93222 }
93223
93224
93225 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_VideoViewSignal(void * jarg1) {
93226   Dali::Signal< void (Dali::Toolkit::VideoView &) > *arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *) 0 ;
93227
93228   arg1 = (Dali::Signal< void (Dali::Toolkit::VideoView &) > *)jarg1;
93229   {
93230     try {
93231       delete arg1;
93232     } catch (std::out_of_range& e) {
93233       {
93234         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93235       };
93236     } catch (std::exception& e) {
93237       {
93238         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93239       };
93240     } catch (Dali::DaliException e) {
93241       {
93242         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93243       };
93244     } catch (...) {
93245       {
93246         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93247       };
93248     }
93249   }
93250
93251 }
93252
93253
93254 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Empty(void * jarg1) {
93255   unsigned int jresult ;
93256   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93257   bool result;
93258
93259   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93260   {
93261     try {
93262       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93263     } catch (std::out_of_range& e) {
93264       {
93265         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93266       };
93267     } catch (std::exception& e) {
93268       {
93269         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93270       };
93271     } catch (Dali::DaliException e) {
93272       {
93273         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93274       };
93275     } catch (...) {
93276       {
93277         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93278       };
93279     }
93280   }
93281
93282   jresult = result;
93283   return jresult;
93284 }
93285
93286
93287 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_GetConnectionCount(void * jarg1) {
93288   unsigned long jresult ;
93289   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93290   std::size_t result;
93291
93292   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93293   {
93294     try {
93295       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,float) > const *)arg1);
93296     } catch (std::out_of_range& e) {
93297       {
93298         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93299       };
93300     } catch (std::exception& e) {
93301       {
93302         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93303       };
93304     } catch (Dali::DaliException e) {
93305       {
93306         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93307       };
93308     } catch (...) {
93309       {
93310         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93311       };
93312     }
93313   }
93314
93315   jresult = (unsigned long)result;
93316   return jresult;
93317 }
93318
93319
93320 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Connect(void * jarg1, void * jarg2) {
93321   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93322   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93323
93324   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93325   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93326   {
93327     try {
93328       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Connect(arg1,arg2);
93329     } catch (std::out_of_range& e) {
93330       {
93331         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93332       };
93333     } catch (std::exception& e) {
93334       {
93335         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93336       };
93337     } catch (Dali::DaliException e) {
93338       {
93339         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93340       };
93341     } catch (...) {
93342       {
93343         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93344       };
93345     }
93346   }
93347
93348 }
93349
93350
93351 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Disconnect(void * jarg1, void * jarg2) {
93352   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93353   bool (*arg2)(Dali::Toolkit::Slider,float) = (bool (*)(Dali::Toolkit::Slider,float)) 0 ;
93354
93355   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93356   arg2 = (bool (*)(Dali::Toolkit::Slider,float))jarg2;
93357   {
93358     try {
93359       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Disconnect(arg1,arg2);
93360     } catch (std::out_of_range& e) {
93361       {
93362         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93363       };
93364     } catch (std::exception& e) {
93365       {
93366         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93367       };
93368     } catch (Dali::DaliException e) {
93369       {
93370         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93371       };
93372     } catch (...) {
93373       {
93374         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93375       };
93376     }
93377   }
93378
93379 }
93380
93381
93382 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderValueChangedSignal_Emit(void * jarg1, void * jarg2, float jarg3) {
93383   unsigned int jresult ;
93384   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93385   Dali::Toolkit::Slider arg2 ;
93386   float arg3 ;
93387   Dali::Toolkit::Slider *argp2 ;
93388   bool result;
93389
93390   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93391   argp2 = (Dali::Toolkit::Slider *)jarg2;
93392   if (!argp2) {
93393     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93394     return 0;
93395   }
93396   arg2 = *argp2;
93397   arg3 = (float)jarg3;
93398   {
93399     try {
93400       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_float_SP__Sg__Emit(arg1,arg2,arg3);
93401     } catch (std::out_of_range& e) {
93402       {
93403         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93404       };
93405     } catch (std::exception& e) {
93406       {
93407         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93408       };
93409     } catch (Dali::DaliException e) {
93410       {
93411         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93412       };
93413     } catch (...) {
93414       {
93415         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93416       };
93417     }
93418   }
93419
93420   jresult = result;
93421   return jresult;
93422 }
93423
93424
93425 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderValueChangedSignal() {
93426   void * jresult ;
93427   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *result = 0 ;
93428
93429   {
93430     try {
93431       result = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,float) >();
93432     } catch (std::out_of_range& e) {
93433       {
93434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93435       };
93436     } catch (std::exception& e) {
93437       {
93438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93439       };
93440     } catch (Dali::DaliException e) {
93441       {
93442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93443       };
93444     } catch (...) {
93445       {
93446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93447       };
93448     }
93449   }
93450
93451   jresult = (void *)result;
93452   return jresult;
93453 }
93454
93455
93456 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderValueChangedSignal(void * jarg1) {
93457   Dali::Signal< bool (Dali::Toolkit::Slider,float) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *) 0 ;
93458
93459   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,float) > *)jarg1;
93460   {
93461     try {
93462       delete arg1;
93463     } catch (std::out_of_range& e) {
93464       {
93465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93466       };
93467     } catch (std::exception& e) {
93468       {
93469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93470       };
93471     } catch (Dali::DaliException e) {
93472       {
93473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93474       };
93475     } catch (...) {
93476       {
93477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93478       };
93479     }
93480   }
93481
93482 }
93483
93484
93485 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Empty(void * jarg1) {
93486   unsigned int jresult ;
93487   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93488   bool result;
93489
93490   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93491   {
93492     try {
93493       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Empty((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93494     } catch (std::out_of_range& e) {
93495       {
93496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93497       };
93498     } catch (std::exception& e) {
93499       {
93500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93501       };
93502     } catch (Dali::DaliException e) {
93503       {
93504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93505       };
93506     } catch (...) {
93507       {
93508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93509       };
93510     }
93511   }
93512
93513   jresult = result;
93514   return jresult;
93515 }
93516
93517
93518 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_GetConnectionCount(void * jarg1) {
93519   unsigned long jresult ;
93520   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93521   std::size_t result;
93522
93523   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93524   {
93525     try {
93526       result = Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__GetConnectionCount((Dali::Signal< bool (Dali::Toolkit::Slider,int) > const *)arg1);
93527     } catch (std::out_of_range& e) {
93528       {
93529         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93530       };
93531     } catch (std::exception& e) {
93532       {
93533         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93534       };
93535     } catch (Dali::DaliException e) {
93536       {
93537         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93538       };
93539     } catch (...) {
93540       {
93541         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93542       };
93543     }
93544   }
93545
93546   jresult = (unsigned long)result;
93547   return jresult;
93548 }
93549
93550
93551 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Connect(void * jarg1, void * jarg2) {
93552   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93553   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93554
93555   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93556   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93557   {
93558     try {
93559       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Connect(arg1,arg2);
93560     } catch (std::out_of_range& e) {
93561       {
93562         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93563       };
93564     } catch (std::exception& e) {
93565       {
93566         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93567       };
93568     } catch (Dali::DaliException e) {
93569       {
93570         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93571       };
93572     } catch (...) {
93573       {
93574         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93575       };
93576     }
93577   }
93578
93579 }
93580
93581
93582 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Disconnect(void * jarg1, void * jarg2) {
93583   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93584   bool (*arg2)(Dali::Toolkit::Slider,int) = (bool (*)(Dali::Toolkit::Slider,int)) 0 ;
93585
93586   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93587   arg2 = (bool (*)(Dali::Toolkit::Slider,int))jarg2;
93588   {
93589     try {
93590       Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Disconnect(arg1,arg2);
93591     } catch (std::out_of_range& e) {
93592       {
93593         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93594       };
93595     } catch (std::exception& e) {
93596       {
93597         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93598       };
93599     } catch (Dali::DaliException e) {
93600       {
93601         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93602       };
93603     } catch (...) {
93604       {
93605         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93606       };
93607     }
93608   }
93609
93610 }
93611
93612
93613 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_SliderMarkReachedSignal_Emit(void * jarg1, void * jarg2, int jarg3) {
93614   unsigned int jresult ;
93615   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93616   Dali::Toolkit::Slider arg2 ;
93617   int arg3 ;
93618   Dali::Toolkit::Slider *argp2 ;
93619   bool result;
93620
93621   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93622   argp2 = (Dali::Toolkit::Slider *)jarg2;
93623   if (!argp2) {
93624     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Slider", 0);
93625     return 0;
93626   }
93627   arg2 = *argp2;
93628   arg3 = (int)jarg3;
93629   {
93630     try {
93631       result = (bool)Dali_Signal_Sl_bool_Sp_Dali_Toolkit_Slider_Sc_int_SP__Sg__Emit(arg1,arg2,arg3);
93632     } catch (std::out_of_range& e) {
93633       {
93634         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93635       };
93636     } catch (std::exception& e) {
93637       {
93638         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93639       };
93640     } catch (Dali::DaliException e) {
93641       {
93642         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93643       };
93644     } catch (...) {
93645       {
93646         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93647       };
93648     }
93649   }
93650
93651   jresult = result;
93652   return jresult;
93653 }
93654
93655
93656 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_SliderMarkReachedSignal() {
93657   void * jresult ;
93658   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *result = 0 ;
93659
93660   {
93661     try {
93662       result = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)new Dali::Signal< bool (Dali::Toolkit::Slider,int) >();
93663     } catch (std::out_of_range& e) {
93664       {
93665         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93666       };
93667     } catch (std::exception& e) {
93668       {
93669         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93670       };
93671     } catch (Dali::DaliException e) {
93672       {
93673         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93674       };
93675     } catch (...) {
93676       {
93677         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93678       };
93679     }
93680   }
93681
93682   jresult = (void *)result;
93683   return jresult;
93684 }
93685
93686
93687 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_SliderMarkReachedSignal(void * jarg1) {
93688   Dali::Signal< bool (Dali::Toolkit::Slider,int) > *arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *) 0 ;
93689
93690   arg1 = (Dali::Signal< bool (Dali::Toolkit::Slider,int) > *)jarg1;
93691   {
93692     try {
93693       delete arg1;
93694     } catch (std::out_of_range& e) {
93695       {
93696         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93697       };
93698     } catch (std::exception& e) {
93699       {
93700         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93701       };
93702     } catch (Dali::DaliException e) {
93703       {
93704         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93705       };
93706     } catch (...) {
93707       {
93708         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93709       };
93710     }
93711   }
93712
93713 }
93714
93715
93716 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_0() {
93717   void * jresult ;
93718   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93719
93720   {
93721     try {
93722       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >();
93723     } catch (std::out_of_range& e) {
93724       {
93725         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93726       };
93727     } catch (std::exception& e) {
93728       {
93729         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93730       };
93731     } catch (Dali::DaliException e) {
93732       {
93733         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93734       };
93735     } catch (...) {
93736       {
93737         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93738       };
93739     }
93740   }
93741
93742   jresult = (void *)result;
93743   return jresult;
93744 }
93745
93746
93747 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_1(void * jarg1) {
93748   void * jresult ;
93749   Dali::Toolkit::Ruler *arg1 = (Dali::Toolkit::Ruler *) 0 ;
93750   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93751
93752   arg1 = (Dali::Toolkit::Ruler *)jarg1;
93753   {
93754     try {
93755       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >(arg1);
93756     } catch (std::out_of_range& e) {
93757       {
93758         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93759       };
93760     } catch (std::exception& e) {
93761       {
93762         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93763       };
93764     } catch (Dali::DaliException e) {
93765       {
93766         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93767       };
93768     } catch (...) {
93769       {
93770         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93771       };
93772     }
93773   }
93774
93775   jresult = (void *)result;
93776   return jresult;
93777 }
93778
93779
93780 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_RulerPtr__SWIG_2(void * jarg1) {
93781   void * jresult ;
93782   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = 0 ;
93783   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93784
93785   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93786   if (!arg1) {
93787     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93788     return 0;
93789   }
93790   {
93791     try {
93792       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)new Dali::IntrusivePtr< Dali::Toolkit::Ruler >((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg1);
93793     } catch (std::out_of_range& e) {
93794       {
93795         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93796       };
93797     } catch (std::exception& e) {
93798       {
93799         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93800       };
93801     } catch (Dali::DaliException e) {
93802       {
93803         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93804       };
93805     } catch (...) {
93806       {
93807         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93808       };
93809     }
93810   }
93811
93812   jresult = (void *)result;
93813   return jresult;
93814 }
93815
93816
93817 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_RulerPtr(void * jarg1) {
93818   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93819
93820   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93821   {
93822     try {
93823       delete arg1;
93824     } catch (std::out_of_range& e) {
93825       {
93826         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
93827       };
93828     } catch (std::exception& e) {
93829       {
93830         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
93831       };
93832     } catch (Dali::DaliException e) {
93833       {
93834         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
93835       };
93836     } catch (...) {
93837       {
93838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
93839       };
93840     }
93841   }
93842
93843 }
93844
93845
93846 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Get(void * jarg1) {
93847   void * jresult ;
93848   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93849   Dali::Toolkit::Ruler *result = 0 ;
93850
93851   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93852   {
93853     try {
93854       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->Get();
93855     } catch (std::out_of_range& e) {
93856       {
93857         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93858       };
93859     } catch (std::exception& e) {
93860       {
93861         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93862       };
93863     } catch (Dali::DaliException e) {
93864       {
93865         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93866       };
93867     } catch (...) {
93868       {
93869         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93870       };
93871     }
93872   }
93873
93874   jresult = (void *)result;
93875   return jresult;
93876 }
93877
93878
93879 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___deref__(void * jarg1) {
93880   void * jresult ;
93881   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93882   Dali::Toolkit::Ruler *result = 0 ;
93883
93884   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93885   {
93886     try {
93887       result = (Dali::Toolkit::Ruler *)((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator ->();
93888     } catch (std::out_of_range& e) {
93889       {
93890         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93891       };
93892     } catch (std::exception& e) {
93893       {
93894         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93895       };
93896     } catch (Dali::DaliException e) {
93897       {
93898         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93899       };
93900     } catch (...) {
93901       {
93902         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93903       };
93904     }
93905   }
93906
93907   jresult = (void *)result;
93908   return jresult;
93909 }
93910
93911
93912 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr___ref__(void * jarg1) {
93913   void * jresult ;
93914   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93915   Dali::Toolkit::Ruler *result = 0 ;
93916
93917   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93918   {
93919     try {
93920       result = (Dali::Toolkit::Ruler *) &((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const *)arg1)->operator *();
93921     } catch (std::out_of_range& e) {
93922       {
93923         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93924       };
93925     } catch (std::exception& e) {
93926       {
93927         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93928       };
93929     } catch (Dali::DaliException e) {
93930       {
93931         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93932       };
93933     } catch (...) {
93934       {
93935         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93936       };
93937     }
93938   }
93939
93940   jresult = (void *)result;
93941   return jresult;
93942 }
93943
93944
93945 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_0(void * jarg1, void * jarg2) {
93946   void * jresult ;
93947   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93948   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg2 = 0 ;
93949   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93950
93951   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93952   arg2 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg2;
93953   if (!arg2) {
93954     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::IntrusivePtr< Dali::Toolkit::Ruler > const & type is null", 0);
93955     return 0;
93956   }
93957   {
93958     try {
93959       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =((Dali::IntrusivePtr< Dali::Toolkit::Ruler > const &)*arg2);
93960     } catch (std::out_of_range& e) {
93961       {
93962         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93963       };
93964     } catch (std::exception& e) {
93965       {
93966         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
93967       };
93968     } catch (Dali::DaliException e) {
93969       {
93970         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
93971       };
93972     } catch (...) {
93973       {
93974         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
93975       };
93976     }
93977   }
93978
93979   jresult = (void *)result;
93980   return jresult;
93981 }
93982
93983
93984 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Assign__SWIG_1(void * jarg1, void * jarg2) {
93985   void * jresult ;
93986   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
93987   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
93988   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *result = 0 ;
93989
93990   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
93991   arg2 = (Dali::Toolkit::Ruler *)jarg2;
93992   {
93993     try {
93994       result = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) &(arg1)->operator =(arg2);
93995     } catch (std::out_of_range& e) {
93996       {
93997         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
93998       };
93999     } catch (std::exception& e) {
94000       {
94001         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94002       };
94003     } catch (Dali::DaliException e) {
94004       {
94005         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94006       };
94007     } catch (...) {
94008       {
94009         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94010       };
94011     }
94012   }
94013
94014   jresult = (void *)result;
94015   return jresult;
94016 }
94017
94018
94019 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_0(void * jarg1) {
94020   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94021
94022   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94023   {
94024     try {
94025       (arg1)->Reset();
94026     } catch (std::out_of_range& e) {
94027       {
94028         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94029       };
94030     } catch (std::exception& e) {
94031       {
94032         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94033       };
94034     } catch (Dali::DaliException e) {
94035       {
94036         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94037       };
94038     } catch (...) {
94039       {
94040         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94041       };
94042     }
94043   }
94044
94045 }
94046
94047
94048 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reset__SWIG_1(void * jarg1, void * jarg2) {
94049   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94050   Dali::Toolkit::Ruler *arg2 = (Dali::Toolkit::Ruler *) 0 ;
94051
94052   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94053   arg2 = (Dali::Toolkit::Ruler *)jarg2;
94054   {
94055     try {
94056       (arg1)->Reset(arg2);
94057     } catch (std::out_of_range& e) {
94058       {
94059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94060       };
94061     } catch (std::exception& e) {
94062       {
94063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94064       };
94065     } catch (Dali::DaliException e) {
94066       {
94067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94068       };
94069     } catch (...) {
94070       {
94071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94072       };
94073     }
94074   }
94075
94076 }
94077
94078
94079 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_Detach(void * jarg1) {
94080   void * jresult ;
94081   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94082   Dali::Toolkit::Ruler *result = 0 ;
94083
94084   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94085   {
94086     try {
94087       result = (Dali::Toolkit::Ruler *)(arg1)->Detach();
94088     } catch (std::out_of_range& e) {
94089       {
94090         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94091       };
94092     } catch (std::exception& e) {
94093       {
94094         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94095       };
94096     } catch (Dali::DaliException e) {
94097       {
94098         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94099       };
94100     } catch (...) {
94101       {
94102         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94103       };
94104     }
94105   }
94106
94107   jresult = (void *)result;
94108   return jresult;
94109 }
94110
94111
94112 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_0(void * jarg1, float jarg2, float jarg3) {
94113   float jresult ;
94114   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94115   float arg2 ;
94116   float arg3 ;
94117   float result;
94118
94119   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94120   arg2 = (float)jarg2;
94121   arg3 = (float)jarg3;
94122   {
94123     try {
94124       result = (float)(*arg1)->Snap(arg2,arg3);
94125     } catch (std::out_of_range& e) {
94126       {
94127         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94128       };
94129     } catch (std::exception& e) {
94130       {
94131         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94132       };
94133     } catch (Dali::DaliException e) {
94134       {
94135         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94136       };
94137     } catch (...) {
94138       {
94139         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94140       };
94141     }
94142   }
94143
94144   jresult = result;
94145   return jresult;
94146 }
94147
94148
94149 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Snap__SWIG_1(void * jarg1, float jarg2) {
94150   float jresult ;
94151   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94152   float arg2 ;
94153   float result;
94154
94155   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94156   arg2 = (float)jarg2;
94157   {
94158     try {
94159       result = (float)(*arg1)->Snap(arg2);
94160     } catch (std::out_of_range& e) {
94161       {
94162         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94163       };
94164     } catch (std::exception& e) {
94165       {
94166         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94167       };
94168     } catch (Dali::DaliException e) {
94169       {
94170         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94171       };
94172     } catch (...) {
94173       {
94174         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94175       };
94176     }
94177   }
94178
94179   jresult = result;
94180   return jresult;
94181 }
94182
94183
94184 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_GetPositionFromPage(void * jarg1, unsigned int jarg2, unsigned int * jarg3, unsigned int jarg4) {
94185   float jresult ;
94186   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94187   unsigned int arg2 ;
94188   unsigned int *arg3 = 0 ;
94189   bool arg4 ;
94190   float result;
94191
94192   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94193   arg2 = (unsigned int)jarg2;
94194   arg3 = (unsigned int *)jarg3;
94195   arg4 = jarg4 ? true : false;
94196   {
94197     try {
94198       result = (float)(*arg1)->GetPositionFromPage(arg2,*arg3,arg4);
94199     } catch (std::out_of_range& e) {
94200       {
94201         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94202       };
94203     } catch (std::exception& e) {
94204       {
94205         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94206       };
94207     } catch (Dali::DaliException e) {
94208       {
94209         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94210       };
94211     } catch (...) {
94212       {
94213         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94214       };
94215     }
94216   }
94217
94218   jresult = result;
94219   return jresult;
94220 }
94221
94222
94223 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetPageFromPosition(void * jarg1, float jarg2, unsigned int jarg3) {
94224   unsigned int jresult ;
94225   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94226   float arg2 ;
94227   bool arg3 ;
94228   unsigned int result;
94229
94230   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94231   arg2 = (float)jarg2;
94232   arg3 = jarg3 ? true : false;
94233   {
94234     try {
94235       result = (unsigned int)(*arg1)->GetPageFromPosition(arg2,arg3);
94236     } catch (std::out_of_range& e) {
94237       {
94238         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94239       };
94240     } catch (std::exception& e) {
94241       {
94242         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94243       };
94244     } catch (Dali::DaliException e) {
94245       {
94246         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94247       };
94248     } catch (...) {
94249       {
94250         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94251       };
94252     }
94253   }
94254
94255   jresult = result;
94256   return jresult;
94257 }
94258
94259
94260 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_GetTotalPages(void * jarg1) {
94261   unsigned int jresult ;
94262   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94263   unsigned int result;
94264
94265   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94266   {
94267     try {
94268       result = (unsigned int)(*arg1)->GetTotalPages();
94269     } catch (std::out_of_range& e) {
94270       {
94271         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94272       };
94273     } catch (std::exception& e) {
94274       {
94275         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94276       };
94277     } catch (Dali::DaliException e) {
94278       {
94279         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94280       };
94281     } catch (...) {
94282       {
94283         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94284       };
94285     }
94286   }
94287
94288   jresult = result;
94289   return jresult;
94290 }
94291
94292
94293 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_GetType(void * jarg1) {
94294   int jresult ;
94295   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94296   Dali::Toolkit::Ruler::RulerType result;
94297
94298   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94299   {
94300     try {
94301       result = (Dali::Toolkit::Ruler::RulerType)(*arg1)->GetType();
94302     } catch (std::out_of_range& e) {
94303       {
94304         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94305       };
94306     } catch (std::exception& e) {
94307       {
94308         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94309       };
94310     } catch (Dali::DaliException e) {
94311       {
94312         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94313       };
94314     } catch (...) {
94315       {
94316         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94317       };
94318     }
94319   }
94320
94321   jresult = (int)result;
94322   return jresult;
94323 }
94324
94325
94326 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_RulerPtr_IsEnabled(void * jarg1) {
94327   unsigned int jresult ;
94328   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94329   bool result;
94330
94331   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94332   {
94333     try {
94334       result = (bool)(*arg1)->IsEnabled();
94335     } catch (std::out_of_range& e) {
94336       {
94337         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94338       };
94339     } catch (std::exception& e) {
94340       {
94341         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94342       };
94343     } catch (Dali::DaliException e) {
94344       {
94345         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94346       };
94347     } catch (...) {
94348       {
94349         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94350       };
94351     }
94352   }
94353
94354   jresult = result;
94355   return jresult;
94356 }
94357
94358
94359 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Enable(void * jarg1) {
94360   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94361
94362   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94363   {
94364     try {
94365       (*arg1)->Enable();
94366     } catch (std::out_of_range& e) {
94367       {
94368         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94369       };
94370     } catch (std::exception& e) {
94371       {
94372         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94373       };
94374     } catch (Dali::DaliException e) {
94375       {
94376         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94377       };
94378     } catch (...) {
94379       {
94380         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94381       };
94382     }
94383   }
94384
94385 }
94386
94387
94388 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Disable(void * jarg1) {
94389   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94390
94391   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94392   {
94393     try {
94394       (*arg1)->Disable();
94395     } catch (std::out_of_range& e) {
94396       {
94397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94398       };
94399     } catch (std::exception& e) {
94400       {
94401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94402       };
94403     } catch (Dali::DaliException e) {
94404       {
94405         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94406       };
94407     } catch (...) {
94408       {
94409         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94410       };
94411     }
94412   }
94413
94414 }
94415
94416
94417 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_SetDomain(void * jarg1, void * jarg2) {
94418   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94419   SwigValueWrapper< Dali::Toolkit::RulerDomain > arg2 ;
94420   Dali::Toolkit::RulerDomain *argp2 ;
94421
94422   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94423   argp2 = (Dali::Toolkit::RulerDomain *)jarg2;
94424   if (!argp2) {
94425     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::RulerDomain", 0);
94426     return ;
94427   }
94428   arg2 = *argp2;
94429   {
94430     try {
94431       (*arg1)->SetDomain(arg2);
94432     } catch (std::out_of_range& e) {
94433       {
94434         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94435       };
94436     } catch (std::exception& e) {
94437       {
94438         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94439       };
94440     } catch (Dali::DaliException e) {
94441       {
94442         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94443       };
94444     } catch (...) {
94445       {
94446         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94447       };
94448     }
94449   }
94450
94451 }
94452
94453
94454 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_RulerPtr_GetDomain(void * jarg1) {
94455   void * jresult ;
94456   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94457   Dali::Toolkit::RulerDomain *result = 0 ;
94458
94459   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94460   {
94461     try {
94462       result = (Dali::Toolkit::RulerDomain *) &(*arg1)->GetDomain();
94463     } catch (std::out_of_range& e) {
94464       {
94465         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94466       };
94467     } catch (std::exception& e) {
94468       {
94469         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94470       };
94471     } catch (Dali::DaliException e) {
94472       {
94473         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94474       };
94475     } catch (...) {
94476       {
94477         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94478       };
94479     }
94480   }
94481
94482   jresult = (void *)result;
94483   return jresult;
94484 }
94485
94486
94487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_DisableDomain(void * jarg1) {
94488   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94489
94490   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94491   {
94492     try {
94493       (*arg1)->DisableDomain();
94494     } catch (std::out_of_range& e) {
94495       {
94496         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94497       };
94498     } catch (std::exception& e) {
94499       {
94500         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94501       };
94502     } catch (Dali::DaliException e) {
94503       {
94504         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94505       };
94506     } catch (...) {
94507       {
94508         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94509       };
94510     }
94511   }
94512
94513 }
94514
94515
94516 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4) {
94517   float jresult ;
94518   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94519   float arg2 ;
94520   float arg3 ;
94521   float arg4 ;
94522   float result;
94523
94524   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94525   arg2 = (float)jarg2;
94526   arg3 = (float)jarg3;
94527   arg4 = (float)jarg4;
94528   {
94529     try {
94530       result = (float)(*arg1)->Clamp(arg2,arg3,arg4);
94531     } catch (std::out_of_range& e) {
94532       {
94533         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94534       };
94535     } catch (std::exception& e) {
94536       {
94537         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94538       };
94539     } catch (Dali::DaliException e) {
94540       {
94541         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94542       };
94543     } catch (...) {
94544       {
94545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94546       };
94547     }
94548   }
94549
94550   jresult = result;
94551   return jresult;
94552 }
94553
94554
94555 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_1(void * jarg1, float jarg2, float jarg3) {
94556   float jresult ;
94557   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94558   float arg2 ;
94559   float arg3 ;
94560   float result;
94561
94562   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94563   arg2 = (float)jarg2;
94564   arg3 = (float)jarg3;
94565   {
94566     try {
94567       result = (float)(*arg1)->Clamp(arg2,arg3);
94568     } catch (std::out_of_range& e) {
94569       {
94570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94571       };
94572     } catch (std::exception& e) {
94573       {
94574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94575       };
94576     } catch (Dali::DaliException e) {
94577       {
94578         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94579       };
94580     } catch (...) {
94581       {
94582         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94583       };
94584     }
94585   }
94586
94587   jresult = result;
94588   return jresult;
94589 }
94590
94591
94592 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_2(void * jarg1, float jarg2) {
94593   float jresult ;
94594   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94595   float arg2 ;
94596   float result;
94597
94598   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94599   arg2 = (float)jarg2;
94600   {
94601     try {
94602       result = (float)(*arg1)->Clamp(arg2);
94603     } catch (std::out_of_range& e) {
94604       {
94605         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94606       };
94607     } catch (std::exception& e) {
94608       {
94609         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94610       };
94611     } catch (Dali::DaliException e) {
94612       {
94613         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94614       };
94615     } catch (...) {
94616       {
94617         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94618       };
94619     }
94620   }
94621
94622   jresult = result;
94623   return jresult;
94624 }
94625
94626
94627 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_Clamp__SWIG_3(void * jarg1, float jarg2, float jarg3, float jarg4, void * jarg5) {
94628   float jresult ;
94629   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94630   float arg2 ;
94631   float arg3 ;
94632   float arg4 ;
94633   Dali::Toolkit::ClampState *arg5 = 0 ;
94634   float result;
94635
94636   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94637   arg2 = (float)jarg2;
94638   arg3 = (float)jarg3;
94639   arg4 = (float)jarg4;
94640   arg5 = (Dali::Toolkit::ClampState *)jarg5;
94641   if (!arg5) {
94642     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94643     return 0;
94644   }
94645   {
94646     try {
94647       result = (float)(*arg1)->Clamp(arg2,arg3,arg4,*arg5);
94648     } catch (std::out_of_range& e) {
94649       {
94650         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94651       };
94652     } catch (std::exception& e) {
94653       {
94654         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94655       };
94656     } catch (Dali::DaliException e) {
94657       {
94658         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94659       };
94660     } catch (...) {
94661       {
94662         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94663       };
94664     }
94665   }
94666
94667   jresult = result;
94668   return jresult;
94669 }
94670
94671
94672 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_0(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5) {
94673   float jresult ;
94674   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94675   float arg2 ;
94676   float arg3 ;
94677   float arg4 ;
94678   float arg5 ;
94679   float result;
94680
94681   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94682   arg2 = (float)jarg2;
94683   arg3 = (float)jarg3;
94684   arg4 = (float)jarg4;
94685   arg5 = (float)jarg5;
94686   {
94687     try {
94688       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5);
94689     } catch (std::out_of_range& e) {
94690       {
94691         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94692       };
94693     } catch (std::exception& e) {
94694       {
94695         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94696       };
94697     } catch (Dali::DaliException e) {
94698       {
94699         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94700       };
94701     } catch (...) {
94702       {
94703         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94704       };
94705     }
94706   }
94707
94708   jresult = result;
94709   return jresult;
94710 }
94711
94712
94713 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_1(void * jarg1, float jarg2, float jarg3, float jarg4) {
94714   float jresult ;
94715   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94716   float arg2 ;
94717   float arg3 ;
94718   float arg4 ;
94719   float result;
94720
94721   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94722   arg2 = (float)jarg2;
94723   arg3 = (float)jarg3;
94724   arg4 = (float)jarg4;
94725   {
94726     try {
94727       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4);
94728     } catch (std::out_of_range& e) {
94729       {
94730         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94731       };
94732     } catch (std::exception& e) {
94733       {
94734         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94735       };
94736     } catch (Dali::DaliException e) {
94737       {
94738         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94739       };
94740     } catch (...) {
94741       {
94742         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94743       };
94744     }
94745   }
94746
94747   jresult = result;
94748   return jresult;
94749 }
94750
94751
94752 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_2(void * jarg1, float jarg2, float jarg3) {
94753   float jresult ;
94754   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94755   float arg2 ;
94756   float arg3 ;
94757   float result;
94758
94759   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94760   arg2 = (float)jarg2;
94761   arg3 = (float)jarg3;
94762   {
94763     try {
94764       result = (float)(*arg1)->SnapAndClamp(arg2,arg3);
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 float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_3(void * jarg1, float jarg2) {
94790   float jresult ;
94791   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94792   float arg2 ;
94793   float result;
94794
94795   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94796   arg2 = (float)jarg2;
94797   {
94798     try {
94799       result = (float)(*arg1)->SnapAndClamp(arg2);
94800     } catch (std::out_of_range& e) {
94801       {
94802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94803       };
94804     } catch (std::exception& e) {
94805       {
94806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94807       };
94808     } catch (Dali::DaliException e) {
94809       {
94810         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94811       };
94812     } catch (...) {
94813       {
94814         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94815       };
94816     }
94817   }
94818
94819   jresult = result;
94820   return jresult;
94821 }
94822
94823
94824 SWIGEXPORT float SWIGSTDCALL CSharp_Dali_RulerPtr_SnapAndClamp__SWIG_4(void * jarg1, float jarg2, float jarg3, float jarg4, float jarg5, void * jarg6) {
94825   float jresult ;
94826   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94827   float arg2 ;
94828   float arg3 ;
94829   float arg4 ;
94830   float arg5 ;
94831   Dali::Toolkit::ClampState *arg6 = 0 ;
94832   float result;
94833
94834   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94835   arg2 = (float)jarg2;
94836   arg3 = (float)jarg3;
94837   arg4 = (float)jarg4;
94838   arg5 = (float)jarg5;
94839   arg6 = (Dali::Toolkit::ClampState *)jarg6;
94840   if (!arg6) {
94841     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::ClampState & type is null", 0);
94842     return 0;
94843   }
94844   {
94845     try {
94846       result = (float)(*arg1)->SnapAndClamp(arg2,arg3,arg4,arg5,*arg6);
94847     } catch (std::out_of_range& e) {
94848       {
94849         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94850       };
94851     } catch (std::exception& e) {
94852       {
94853         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94854       };
94855     } catch (Dali::DaliException e) {
94856       {
94857         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94858       };
94859     } catch (...) {
94860       {
94861         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94862       };
94863     }
94864   }
94865
94866   jresult = result;
94867   return jresult;
94868 }
94869
94870
94871 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Reference(void * jarg1) {
94872   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94873
94874   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94875   {
94876     try {
94877       (*arg1)->Reference();
94878     } catch (std::out_of_range& e) {
94879       {
94880         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94881       };
94882     } catch (std::exception& e) {
94883       {
94884         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94885       };
94886     } catch (Dali::DaliException e) {
94887       {
94888         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94889       };
94890     } catch (...) {
94891       {
94892         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94893       };
94894     }
94895   }
94896
94897 }
94898
94899
94900 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_RulerPtr_Unreference(void * jarg1) {
94901   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94902
94903   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94904   {
94905     try {
94906       (*arg1)->Unreference();
94907     } catch (std::out_of_range& e) {
94908       {
94909         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
94910       };
94911     } catch (std::exception& e) {
94912       {
94913         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
94914       };
94915     } catch (Dali::DaliException e) {
94916       {
94917         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
94918       };
94919     } catch (...) {
94920       {
94921         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
94922       };
94923     }
94924   }
94925
94926 }
94927
94928
94929 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_RulerPtr_ReferenceCount(void * jarg1) {
94930   int jresult ;
94931   Dali::IntrusivePtr< Dali::Toolkit::Ruler > *arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *) 0 ;
94932   int result;
94933
94934   arg1 = (Dali::IntrusivePtr< Dali::Toolkit::Ruler > *)jarg1;
94935   {
94936     try {
94937       result = (int)(*arg1)->ReferenceCount();
94938     } catch (std::out_of_range& e) {
94939       {
94940         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94941       };
94942     } catch (std::exception& e) {
94943       {
94944         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94945       };
94946     } catch (Dali::DaliException e) {
94947       {
94948         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94949       };
94950     } catch (...) {
94951       {
94952         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94953       };
94954     }
94955   }
94956
94957   jresult = result;
94958   return jresult;
94959 }
94960
94961
94962 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Empty(void * jarg1) {
94963   unsigned int jresult ;
94964   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94965   bool result;
94966
94967   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
94968   {
94969     try {
94970       result = (bool)Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Empty((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
94971     } catch (std::out_of_range& e) {
94972       {
94973         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
94974       };
94975     } catch (std::exception& e) {
94976       {
94977         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
94978       };
94979     } catch (Dali::DaliException e) {
94980       {
94981         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
94982       };
94983     } catch (...) {
94984       {
94985         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
94986       };
94987     }
94988   }
94989
94990   jresult = result;
94991   return jresult;
94992 }
94993
94994
94995 SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_GetConnectionCount(void * jarg1) {
94996   unsigned long jresult ;
94997   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
94998   std::size_t result;
94999
95000   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95001   {
95002     try {
95003       result = Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__GetConnectionCount((Dali::Signal< void (Dali::Toolkit::Control) > const *)arg1);
95004     } catch (std::out_of_range& e) {
95005       {
95006         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95007       };
95008     } catch (std::exception& e) {
95009       {
95010         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95011       };
95012     } catch (Dali::DaliException e) {
95013       {
95014         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95015       };
95016     } catch (...) {
95017       {
95018         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95019       };
95020     }
95021   }
95022
95023   jresult = (unsigned long)result;
95024   return jresult;
95025 }
95026
95027
95028 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Connect(void * jarg1, void * jarg2) {
95029   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95030   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95031
95032   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95033   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95034   {
95035     try {
95036       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Connect(arg1,arg2);
95037     } catch (std::out_of_range& e) {
95038       {
95039         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95040       };
95041     } catch (std::exception& e) {
95042       {
95043         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95044       };
95045     } catch (Dali::DaliException e) {
95046       {
95047         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95048       };
95049     } catch (...) {
95050       {
95051         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95052       };
95053     }
95054   }
95055
95056 }
95057
95058
95059 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Disconnect(void * jarg1, void * jarg2) {
95060   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95061   void (*arg2)(Dali::Toolkit::Control) = (void (*)(Dali::Toolkit::Control)) 0 ;
95062
95063   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95064   arg2 = (void (*)(Dali::Toolkit::Control))jarg2;
95065   {
95066     try {
95067       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Disconnect(arg1,arg2);
95068     } catch (std::out_of_range& e) {
95069       {
95070         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95071       };
95072     } catch (std::exception& e) {
95073       {
95074         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95075       };
95076     } catch (Dali::DaliException e) {
95077       {
95078         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95079       };
95080     } catch (...) {
95081       {
95082         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95083       };
95084     }
95085   }
95086
95087 }
95088
95089
95090 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_ViewResourceReadySignal_Emit(void * jarg1, void * jarg2) {
95091   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95092   Dali::Toolkit::Control arg2 ;
95093   Dali::Toolkit::Control *argp2 ;
95094
95095   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95096   argp2 = (Dali::Toolkit::Control *)jarg2;
95097   if (!argp2) {
95098     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Toolkit::Control", 0);
95099     return ;
95100   }
95101   arg2 = *argp2;
95102   {
95103     try {
95104       Dali_Signal_Sl_void_Sp_Dali_Toolkit_Control_SP__Sg__Emit(arg1,arg2);
95105     } catch (std::out_of_range& e) {
95106       {
95107         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95108       };
95109     } catch (std::exception& e) {
95110       {
95111         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95112       };
95113     } catch (Dali::DaliException e) {
95114       {
95115         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95116       };
95117     } catch (...) {
95118       {
95119         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95120       };
95121     }
95122   }
95123
95124 }
95125
95126
95127 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_ViewResourceReadySignal() {
95128   void * jresult ;
95129   Dali::Signal< void (Dali::Toolkit::Control) > *result = 0 ;
95130
95131   {
95132     try {
95133       result = (Dali::Signal< void (Dali::Toolkit::Control) > *)new Dali::Signal< void (Dali::Toolkit::Control) >();
95134     } catch (std::out_of_range& e) {
95135       {
95136         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95137       };
95138     } catch (std::exception& e) {
95139       {
95140         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95141       };
95142     } catch (Dali::DaliException e) {
95143       {
95144         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
95145       };
95146     } catch (...) {
95147       {
95148         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95149       };
95150     }
95151   }
95152
95153   jresult = (void *)result;
95154   return jresult;
95155 }
95156
95157
95158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_ViewResourceReadySignal(void * jarg1) {
95159   Dali::Signal< void (Dali::Toolkit::Control) > *arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *) 0 ;
95160
95161   arg1 = (Dali::Signal< void (Dali::Toolkit::Control) > *)jarg1;
95162   {
95163     try {
95164       delete arg1;
95165     } catch (std::out_of_range& e) {
95166       {
95167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95168       };
95169     } catch (std::exception& e) {
95170       {
95171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95172       };
95173     } catch (Dali::DaliException e) {
95174       {
95175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
95176       };
95177     } catch (...) {
95178       {
95179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95180       };
95181     }
95182   }
95183
95184 }
95185
95186 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_GetRefObjectPtr(Dali::BaseHandle *arg1) {
95187   Dali::RefObject *result = NULL;
95188
95189   if (arg1)
95190   {
95191     result = (Dali::RefObject *)((Dali::BaseHandle const *)arg1)->GetObjectPtr();
95192   }
95193   return result;
95194 }
95195
95196 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_BaseObject_SWIGUpcast(Dali::BaseObject *jarg1) {
95197     return (Dali::RefObject *)jarg1;
95198 }
95199
95200 SWIGEXPORT Dali::SignalObserver * SWIGSTDCALL CSharp_Dali_ConnectionTrackerInterface_SWIGUpcast(Dali::ConnectionTrackerInterface *jarg1) {
95201     return (Dali::SignalObserver *)jarg1;
95202 }
95203
95204 SWIGEXPORT Dali::ConnectionTrackerInterface * SWIGSTDCALL CSharp_Dali_ConnectionTracker_SWIGUpcast(Dali::ConnectionTracker *jarg1) {
95205     return (Dali::ConnectionTrackerInterface *)jarg1;
95206 }
95207
95208 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ObjectRegistry_SWIGUpcast(Dali::ObjectRegistry *jarg1) {
95209     return (Dali::BaseHandle *)jarg1;
95210 }
95211
95212 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyCondition_SWIGUpcast(Dali::PropertyCondition *jarg1) {
95213     return (Dali::BaseHandle *)jarg1;
95214 }
95215
95216 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyNotification_SWIGUpcast(Dali::PropertyNotification *jarg1) {
95217     return (Dali::BaseHandle *)jarg1;
95218 }
95219
95220 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Handle_SWIGUpcast(Dali::Handle *jarg1) {
95221     return (Dali::BaseHandle *)jarg1;
95222 }
95223
95224 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeInfo_SWIGUpcast(Dali::TypeInfo *jarg1) {
95225     return (Dali::BaseHandle *)jarg1;
95226 }
95227
95228 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TypeRegistry_SWIGUpcast(Dali::TypeRegistry *jarg1) {
95229     return (Dali::BaseHandle *)jarg1;
95230 }
95231
95232 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelData_SWIGUpcast(Dali::PixelData *jarg1) {
95233     return (Dali::BaseHandle *)jarg1;
95234 }
95235
95236 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Texture_SWIGUpcast(Dali::Texture *jarg1) {
95237     return (Dali::BaseHandle *)jarg1;
95238 }
95239
95240 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Sampler_SWIGUpcast(Dali::Sampler *jarg1) {
95241     return (Dali::BaseHandle *)jarg1;
95242 }
95243
95244 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TextureSet_SWIGUpcast(Dali::TextureSet *jarg1) {
95245     return (Dali::BaseHandle *)jarg1;
95246 }
95247
95248 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PropertyBuffer_SWIGUpcast(Dali::PropertyBuffer *jarg1) {
95249     return (Dali::BaseHandle *)jarg1;
95250 }
95251
95252 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Geometry_SWIGUpcast(Dali::Geometry *jarg1) {
95253     return (Dali::BaseHandle *)jarg1;
95254 }
95255
95256 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Shader_SWIGUpcast(Dali::Shader *jarg1) {
95257     return (Dali::Handle *)jarg1;
95258 }
95259
95260 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Renderer_SWIGUpcast(Dali::Renderer *jarg1) {
95261     return (Dali::Handle *)jarg1;
95262 }
95263
95264 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_FrameBuffer_SWIGUpcast(Dali::FrameBuffer *jarg1) {
95265     return (Dali::BaseHandle *)jarg1;
95266 }
95267
95268 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_RenderTaskList_SWIGUpcast(Dali::RenderTaskList *jarg1) {
95269     return (Dali::BaseHandle *)jarg1;
95270 }
95271
95272 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_RenderTask_SWIGUpcast(Dali::RenderTask *jarg1) {
95273     return (Dali::Handle *)jarg1;
95274 }
95275
95276 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Touch_SWIGUpcast(Dali::TouchData *jarg1) {
95277     return (Dali::BaseHandle *)jarg1;
95278 }
95279
95280 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_GestureDetector_SWIGUpcast(Dali::GestureDetector *jarg1) {
95281     return (Dali::Handle *)jarg1;
95282 }
95283
95284 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_LongPressGestureDetector_SWIGUpcast(Dali::LongPressGestureDetector *jarg1) {
95285     return (Dali::GestureDetector *)jarg1;
95286 }
95287
95288 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_LongPressGesture_SWIGUpcast(Dali::LongPressGesture *jarg1) {
95289     return (Dali::Gesture *)jarg1;
95290 }
95291
95292 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Actor_SWIGUpcast(Dali::Actor *jarg1) {
95293     return (Dali::Handle *)jarg1;
95294 }
95295
95296 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_Layer_SWIGUpcast(Dali::Layer *jarg1) {
95297     return (Dali::Actor *)jarg1;
95298 }
95299
95300 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_CustomActorImpl_SWIGUpcast(Dali::CustomActorImpl *jarg1) {
95301     return (Dali::RefObject *)jarg1;
95302 }
95303
95304 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CustomActor_SWIGUpcast(Dali::CustomActor *jarg1) {
95305     return (Dali::Actor *)jarg1;
95306 }
95307
95308 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PanGestureDetector_SWIGUpcast(Dali::PanGestureDetector *jarg1) {
95309     return (Dali::GestureDetector *)jarg1;
95310 }
95311
95312 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PanGesture_SWIGUpcast(Dali::PanGesture *jarg1) {
95313     return (Dali::Gesture *)jarg1;
95314 }
95315
95316 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_PinchGestureDetector_SWIGUpcast(Dali::PinchGestureDetector *jarg1) {
95317     return (Dali::GestureDetector *)jarg1;
95318 }
95319
95320 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_PinchGesture_SWIGUpcast(Dali::PinchGesture *jarg1) {
95321     return (Dali::Gesture *)jarg1;
95322 }
95323
95324 SWIGEXPORT Dali::GestureDetector * SWIGSTDCALL CSharp_Dali_TapGestureDetector_SWIGUpcast(Dali::TapGestureDetector *jarg1) {
95325     return (Dali::GestureDetector *)jarg1;
95326 }
95327
95328 SWIGEXPORT Dali::Gesture * SWIGSTDCALL CSharp_Dali_TapGesture_SWIGUpcast(Dali::TapGesture *jarg1) {
95329     return (Dali::Gesture *)jarg1;
95330 }
95331
95332 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyFrames_SWIGUpcast(Dali::KeyFrames *jarg1) {
95333     return (Dali::BaseHandle *)jarg1;
95334 }
95335
95336 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_Path_SWIGUpcast(Dali::Path *jarg1) {
95337     return (Dali::Handle *)jarg1;
95338 }
95339
95340 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_LinearConstrainer_SWIGUpcast(Dali::LinearConstrainer *jarg1) {
95341     return (Dali::Handle *)jarg1;
95342 }
95343
95344 SWIGEXPORT Dali::Handle * SWIGSTDCALL CSharp_Dali_PathConstrainer_SWIGUpcast(Dali::PathConstrainer *jarg1) {
95345     return (Dali::Handle *)jarg1;
95346 }
95347
95348 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_NativeImageInterface_SWIGUpcast(Dali::NativeImageInterface *jarg1) {
95349     return (Dali::RefObject *)jarg1;
95350 }
95351
95352 SWIGEXPORT Dali::Actor * SWIGSTDCALL CSharp_Dali_CameraActor_SWIGUpcast(Dali::CameraActor *jarg1) {
95353     return (Dali::Actor *)jarg1;
95354 }
95355
95356 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Timer_SWIGUpcast(Dali::Timer *jarg1) {
95357     return (Dali::BaseHandle *)jarg1;
95358 }
95359
95360 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Builder_SWIGUpcast(Dali::Toolkit::Builder *jarg1) {
95361     return (Dali::BaseHandle *)jarg1;
95362 }
95363
95364 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_TransitionData_SWIGUpcast(Dali::Toolkit::TransitionData *jarg1) {
95365     return (Dali::BaseHandle *)jarg1;
95366 }
95367
95368 SWIGEXPORT Dali::CustomActorImpl * SWIGSTDCALL CSharp_Dali_ViewImpl_SWIGUpcast(Dali::Toolkit::Internal::Control *jarg1) {
95369     return (Dali::CustomActorImpl *)jarg1;
95370 }
95371
95372 SWIGEXPORT Dali::CustomActor * SWIGSTDCALL CSharp_Dali_View_SWIGUpcast(Dali::Toolkit::Control *jarg1) {
95373     return (Dali::CustomActor *)jarg1;
95374 }
95375
95376 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_KeyInputFocusManager_SWIGUpcast(Dali::Toolkit::KeyInputFocusManager *jarg1) {
95377     return (Dali::BaseHandle *)jarg1;
95378 }
95379
95380 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Alignment_SWIGUpcast(Dali::Toolkit::Alignment *jarg1) {
95381     return (Dali::Toolkit::Control *)jarg1;
95382 }
95383
95384 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Button_SWIGUpcast(Dali::Toolkit::Button *jarg1) {
95385     return (Dali::Toolkit::Control *)jarg1;
95386 }
95387
95388 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_CheckBoxButton_SWIGUpcast(Dali::Toolkit::CheckBoxButton *jarg1) {
95389     return (Dali::Toolkit::Button *)jarg1;
95390 }
95391
95392 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_PushButton_SWIGUpcast(Dali::Toolkit::PushButton *jarg1) {
95393     return (Dali::Toolkit::Button *)jarg1;
95394 }
95395
95396 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_RadioButton_SWIGUpcast(Dali::Toolkit::RadioButton *jarg1) {
95397     return (Dali::Toolkit::Button *)jarg1;
95398 }
95399
95400 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_FlexContainer_SWIGUpcast(Dali::Toolkit::FlexContainer *jarg1) {
95401     return (Dali::Toolkit::Control *)jarg1;
95402 }
95403
95404 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ImageView_SWIGUpcast(Dali::Toolkit::ImageView *jarg1) {
95405     return (Dali::Toolkit::Control *)jarg1;
95406 }
95407
95408 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Model3dView_SWIGUpcast(Dali::Toolkit::Model3dView *jarg1) {
95409     return (Dali::Toolkit::Control *)jarg1;
95410 }
95411
95412 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ScrollBar_SWIGUpcast(Dali::Toolkit::ScrollBar *jarg1) {
95413     return (Dali::Toolkit::Control *)jarg1;
95414 }
95415
95416 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Scrollable_SWIGUpcast(Dali::Toolkit::Scrollable *jarg1) {
95417     return (Dali::Toolkit::Control *)jarg1;
95418 }
95419
95420 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_ItemLayout_SWIGUpcast(Dali::Toolkit::ItemLayout *jarg1) {
95421     return (Dali::RefObject *)jarg1;
95422 }
95423
95424 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ItemView_SWIGUpcast(Dali::Toolkit::ItemView *jarg1) {
95425     return (Dali::Toolkit::Scrollable *)jarg1;
95426 }
95427
95428 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_ScrollViewEffect_SWIGUpcast(Dali::Toolkit::ScrollViewEffect *jarg1) {
95429     return (Dali::BaseHandle *)jarg1;
95430 }
95431
95432 SWIGEXPORT Dali::Toolkit::ScrollViewEffect * SWIGSTDCALL CSharp_Dali_ScrollViewPagePathEffect_SWIGUpcast(Dali::Toolkit::ScrollViewPagePathEffect *jarg1) {
95433     return (Dali::Toolkit::ScrollViewEffect *)jarg1;
95434 }
95435
95436 SWIGEXPORT Dali::RefObject * SWIGSTDCALL CSharp_Dali_Ruler_SWIGUpcast(Dali::Toolkit::Ruler *jarg1) {
95437     return (Dali::RefObject *)jarg1;
95438 }
95439
95440 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_DefaultRuler_SWIGUpcast(Dali::Toolkit::DefaultRuler *jarg1) {
95441     return (Dali::Toolkit::Ruler *)jarg1;
95442 }
95443
95444 SWIGEXPORT Dali::Toolkit::Ruler * SWIGSTDCALL CSharp_Dali_FixedRuler_SWIGUpcast(Dali::Toolkit::FixedRuler *jarg1) {
95445     return (Dali::Toolkit::Ruler *)jarg1;
95446 }
95447
95448 SWIGEXPORT Dali::Toolkit::Scrollable * SWIGSTDCALL CSharp_Dali_ScrollView_SWIGUpcast(Dali::Toolkit::ScrollView *jarg1) {
95449     return (Dali::Toolkit::Scrollable *)jarg1;
95450 }
95451
95452 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TableView_SWIGUpcast(Dali::Toolkit::TableView *jarg1) {
95453     return (Dali::Toolkit::Control *)jarg1;
95454 }
95455
95456
95457 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_TextLabel_SWIGUpcast(Dali::Toolkit::TextLabel *jarg1) {
95458     return (Dali::Toolkit::Control *)jarg1;
95459 }
95460
95461 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AccessibilityManager_SWIGUpcast(Dali::Toolkit::AccessibilityManager *jarg1) {
95462     return (Dali::BaseHandle *)jarg1;
95463 }
95464
95465 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_StyleManager_SWIGUpcast(Dali::Toolkit::StyleManager *jarg1) {
95466     return (Dali::BaseHandle *)jarg1;
95467 }
95468
95469 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Slider_SWIGUpcast(Dali::Toolkit::Slider *jarg1) {
95470     return (Dali::Toolkit::Control *)jarg1;
95471 }
95472
95473 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_VideoView_SWIGUpcast(Dali::Toolkit::VideoView *jarg1) {
95474     return (Dali::Toolkit::Control *)jarg1;
95475 }
95476
95477 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_Popup_SWIGUpcast(Dali::Toolkit::Popup *jarg1) {
95478     return (Dali::Toolkit::Control *)jarg1;
95479 }
95480
95481 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_ProgressBar_SWIGUpcast(Dali::Toolkit::ProgressBar *jarg1) {
95482     return (Dali::Toolkit::Control *)jarg1;
95483 }
95484
95485 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_GaussianBlurView_SWIGUpcast(Dali::Toolkit::GaussianBlurView *jarg1) {
95486     return (Dali::Toolkit::Control *)jarg1;
95487 }
95488
95489 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_PageTurnView_SWIGUpcast(Dali::Toolkit::PageTurnView *jarg1) {
95490     return (Dali::Toolkit::Control *)jarg1;
95491 }
95492
95493 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnLandscapeView_SWIGUpcast(Dali::Toolkit::PageTurnLandscapeView *jarg1) {
95494     return (Dali::Toolkit::PageTurnView *)jarg1;
95495 }
95496
95497 SWIGEXPORT Dali::Toolkit::PageTurnView * SWIGSTDCALL CSharp_Dali_PageTurnPortraitView_SWIGUpcast(Dali::Toolkit::PageTurnPortraitView *jarg1) {
95498     return (Dali::Toolkit::PageTurnView *)jarg1;
95499 }
95500
95501 SWIGEXPORT Dali::Toolkit::Button * SWIGSTDCALL CSharp_Dali_ToggleButton_SWIGUpcast(Dali::Toolkit::ToggleButton *jarg1) {
95502     return (Dali::Toolkit::Button *)jarg1;
95503 }
95504
95505 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualBase_SWIGUpcast(Dali::Toolkit::Visual::Base *jarg1) {
95506     return (Dali::BaseHandle *)jarg1;
95507 }
95508
95509 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_VisualFactory_SWIGUpcast(Dali::Toolkit::VisualFactory *jarg1) {
95510     return (Dali::BaseHandle *)jarg1;
95511 }
95512
95513 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_AsyncImageLoader_SWIGUpcast(Dali::Toolkit::AsyncImageLoader *jarg1) {
95514     return (Dali::BaseHandle *)jarg1;
95515 }
95516
95517 /*
95518  * Widget binding
95519  */
95520 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_Widget_SWIGUpcast(Dali::Widget *jarg1) {
95521     return (Dali::BaseHandle *)jarg1;
95522 }
95523
95524 SWIGEXPORT Dali::BaseObject * SWIGSTDCALL CSharp_Dali_WidgetImpl_SWIGUpcast(Dali::Internal::Adaptor::Widget *jarg1) {
95525     return (Dali::BaseObject *)jarg1;
95526 }
95527
95528 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_0() {
95529   void * jresult ;
95530   Dali::Widget result;
95531
95532   {
95533     try {
95534       result = Dali::Widget::New();
95535     } catch (std::out_of_range& e) {
95536       {
95537         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95538       };
95539     } catch (std::exception& e) {
95540       {
95541         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95542       };
95543     } catch (...) {
95544       {
95545         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95546       };
95547     }
95548   }
95549   jresult = new Dali::Widget((const Dali::Widget &)result);
95550   return jresult;
95551 }
95552
95553
95554 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_New__SWIG_1(void * jarg1) {
95555   void * jresult ;
95556   Dali::Internal::Adaptor::Widget *arg1 = 0 ;
95557   Dali::Widget result;
95558
95559   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95560
95561   if (!arg1) {
95562     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Internal::Adaptor::Widget & type is null", 0);
95563     return 0;
95564   }
95565   {
95566     try {
95567       jresult = new Dali::Widget(arg1);
95568     } catch (std::out_of_range& e) {
95569       {
95570         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95571       };
95572     } catch (std::exception& e) {
95573       {
95574         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95575       };
95576     } catch (...) {
95577       {
95578         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95579       };
95580     }
95581   }
95582   return jresult;
95583 }
95584
95585
95586 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_Widget() {
95587   void * jresult ;
95588   Dali::Widget *result = 0 ;
95589
95590   {
95591     try {
95592       result = (Dali::Widget *)new Dali::Widget();
95593     } catch (std::out_of_range& e) {
95594       {
95595         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95596       };
95597     } catch (std::exception& e) {
95598       {
95599         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95600       };
95601     } catch (...) {
95602       {
95603         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95604       };
95605     }
95606   }
95607   jresult = (void *)result;
95608   return jresult;
95609 }
95610
95611
95612 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_Assign(void * jarg1, void * jarg2) {
95613   void * jresult ;
95614   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95615   Dali::Widget *arg2 = 0 ;
95616   Dali::Widget *result = 0 ;
95617
95618   arg1 = (Dali::Widget *)jarg1;
95619   arg2 = (Dali::Widget *)jarg2;
95620   if (!arg2) {
95621     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget const & type is null", 0);
95622     return 0;
95623   }
95624   {
95625     try {
95626       result = (Dali::Widget *) &(arg1)->operator =((Dali::Widget const &)*arg2);
95627     } catch (std::out_of_range& e) {
95628       {
95629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95630       };
95631     } catch (std::exception& e) {
95632       {
95633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95634       };
95635     } catch (...) {
95636       {
95637         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95638       };
95639     }
95640   }
95641   jresult = (void *)result;
95642   return jresult;
95643 }
95644
95645
95646 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_Widget(void * jarg1) {
95647   Dali::Widget *arg1 = (Dali::Widget *) 0 ;
95648
95649   arg1 = (Dali::Widget *)jarg1;
95650   {
95651     try {
95652       delete arg1;
95653     } catch (std::out_of_range& e) {
95654       {
95655         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95656       };
95657     } catch (std::exception& e) {
95658       {
95659         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95660       };
95661     } catch (...) {
95662       {
95663         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95664       };
95665     }
95666   }
95667 }
95668
95669
95670 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetImpl_New() {
95671   void * jresult ;
95672   SwigDirector_WidgetImpl* result;
95673   {
95674     try {
95675       result = new SwigDirector_WidgetImpl();
95676     } catch (std::out_of_range& e) {
95677       {
95678         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
95679       };
95680     } catch (std::exception& e) {
95681       {
95682         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
95683       };
95684     } catch (...) {
95685       {
95686         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
95687       };
95688     }
95689   }
95690   jresult = result;
95691   return jresult;
95692 }
95693
95694
95695 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreate(void * jarg1, char * jarg2, void * jarg3) {
95696   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95697   std::string *arg2 = 0 ;
95698   Dali::Window arg3 ;
95699   Dali::Window *argp3 ;
95700
95701   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95702   if (!jarg2) {
95703     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95704     return ;
95705   }
95706   std::string arg2_str(jarg2);
95707   arg2 = &arg2_str;
95708   argp3 = (Dali::Window *)jarg3;
95709   if (!argp3) {
95710     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95711     return ;
95712   }
95713   arg3 = *argp3;
95714   {
95715     try {
95716       (arg1)->OnCreate((std::string const &)*arg2,arg3);
95717     } catch (std::out_of_range& e) {
95718       {
95719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95720       };
95721     } catch (std::exception& e) {
95722       {
95723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95724       };
95725     } catch (...) {
95726       {
95727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95728       };
95729     }
95730   }
95731 }
95732
95733 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnCreateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, void * jarg3) {
95734   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95735   std::string *arg2 = 0 ;
95736   Dali::Window arg3 ;
95737   Dali::Window *argp3 ;
95738
95739   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95740   if (!jarg2) {
95741     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95742     return ;
95743   }
95744   std::string arg2_str(jarg2);
95745   arg2 = &arg2_str;
95746   argp3 = (Dali::Window *)jarg3;
95747   if (!argp3) {
95748     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95749     return ;
95750   }
95751   arg3 = *argp3;
95752   {
95753     try {
95754       (arg1)->Dali::Internal::Adaptor::Widget::OnCreate((std::string const &)*arg2,arg3);
95755     } catch (std::out_of_range& e) {
95756       {
95757         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95758       };
95759     } catch (std::exception& e) {
95760       {
95761         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95762       };
95763     } catch (...) {
95764       {
95765         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95766       };
95767     }
95768   }
95769 }
95770
95771
95772 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminate(void * jarg1, char * jarg2, int jarg3) {
95773   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95774   std::string *arg2 = 0 ;
95775   Dali::Widget::Termination arg3 ;
95776
95777   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95778   if (!jarg2) {
95779     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95780     return ;
95781   }
95782   std::string arg2_str(jarg2);
95783   arg2 = &arg2_str;
95784   arg3 = (Dali::Widget::Termination)jarg3;
95785   {
95786     try {
95787       (arg1)->OnTerminate((std::string const &)*arg2,arg3);
95788     } catch (std::out_of_range& e) {
95789       {
95790         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95791       };
95792     } catch (std::exception& e) {
95793       {
95794         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95795       };
95796     } catch (...) {
95797       {
95798         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95799       };
95800     }
95801   }
95802 }
95803
95804 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnTerminateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
95805   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95806   std::string *arg2 = 0 ;
95807   Dali::Widget::Termination arg3 ;
95808
95809   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95810   if (!jarg2) {
95811     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
95812     return ;
95813   }
95814   std::string arg2_str(jarg2);
95815   arg2 = &arg2_str;
95816   arg3 = (Dali::Widget::Termination)jarg3;
95817   {
95818     try {
95819       (arg1)->Dali::Internal::Adaptor::Widget::OnTerminate((std::string const &)*arg2,arg3);
95820     } catch (std::out_of_range& e) {
95821       {
95822         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95823       };
95824     } catch (std::exception& e) {
95825       {
95826         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95827       };
95828     } catch (...) {
95829       {
95830         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95831       };
95832     }
95833   }
95834 }
95835
95836
95837 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPause(void * jarg1) {
95838   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95839
95840   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95841   {
95842     try {
95843       (arg1)->OnPause();
95844     } catch (std::out_of_range& e) {
95845       {
95846         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95847       };
95848     } catch (std::exception& e) {
95849       {
95850         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95851       };
95852     } catch (...) {
95853       {
95854         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95855       };
95856     }
95857   }
95858 }
95859
95860 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnPauseSwigExplicitWidgetImpl(void * jarg1) {
95861   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95862
95863   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95864   {
95865     try {
95866       (arg1)->Dali::Internal::Adaptor::Widget::OnPause();
95867     } catch (std::out_of_range& e) {
95868       {
95869         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95870       };
95871     } catch (std::exception& e) {
95872       {
95873         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95874       };
95875     } catch (...) {
95876       {
95877         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95878       };
95879     }
95880   }
95881 }
95882
95883
95884 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResume(void * jarg1) {
95885   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95886
95887   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95888   {
95889     try {
95890       (arg1)->OnResume();
95891     } catch (std::out_of_range& e) {
95892       {
95893         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95894       };
95895     } catch (std::exception& e) {
95896       {
95897         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95898       };
95899     } catch (...) {
95900       {
95901         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95902       };
95903     }
95904   }
95905 }
95906
95907
95908 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResumeSwigExplicitWidgetImpl(void * jarg1) {
95909   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95910
95911   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95912   {
95913     try {
95914       (arg1)->Dali::Internal::Adaptor::Widget::OnResume();
95915     } catch (std::out_of_range& e) {
95916       {
95917         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95918       };
95919     } catch (std::exception& e) {
95920       {
95921         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95922       };
95923     } catch (...) {
95924       {
95925         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95926       };
95927     }
95928   }
95929 }
95930
95931
95932 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResize(void * jarg1, void * jarg2) {
95933   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95934   Dali::Window arg2 ;
95935   Dali::Window *argp2 ;
95936
95937   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95938   argp2 = (Dali::Window *)jarg2;
95939   if (!argp2) {
95940     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95941     return ;
95942   }
95943   arg2 = *argp2;
95944   {
95945     try {
95946       (arg1)->OnResize(arg2);
95947     } catch (std::out_of_range& e) {
95948       {
95949         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95950       };
95951     } catch (std::exception& e) {
95952       {
95953         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95954       };
95955     } catch (...) {
95956       {
95957         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95958       };
95959     }
95960   }
95961 }
95962
95963 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnResizeSwigExplicitWidgetImpl(void * jarg1, void * jarg2) {
95964   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95965   Dali::Window arg2 ;
95966   Dali::Window *argp2 ;
95967
95968   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
95969   argp2 = (Dali::Window *)jarg2;
95970   if (!argp2) {
95971     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Window", 0);
95972     return ;
95973   }
95974   arg2 = *argp2;
95975   {
95976     try {
95977       (arg1)->Dali::Internal::Adaptor::Widget::OnResize(arg2);
95978     } catch (std::out_of_range& e) {
95979       {
95980         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
95981       };
95982     } catch (std::exception& e) {
95983       {
95984         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
95985       };
95986     } catch (...) {
95987       {
95988         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
95989       };
95990     }
95991   }
95992 }
95993
95994
95995 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdate(void * jarg1, char * jarg2, int jarg3) {
95996   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
95997   std::string *arg2 = 0 ;
95998   int arg3 ;
95999
96000   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96001   if (!jarg2) {
96002     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96003     return ;
96004   }
96005   std::string arg2_str(jarg2);
96006   arg2 = &arg2_str;
96007   arg3 = (int)jarg3;
96008   {
96009     try {
96010       (arg1)->OnUpdate((std::string const &)*arg2,arg3);
96011     } catch (std::out_of_range& e) {
96012       {
96013         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96014       };
96015     } catch (std::exception& e) {
96016       {
96017         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96018       };
96019     } catch (...) {
96020       {
96021         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96022       };
96023     }
96024   }
96025 }
96026
96027 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_OnUpdateSwigExplicitWidgetImpl(void * jarg1, char * jarg2, int jarg3) {
96028   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96029   std::string *arg2 = 0 ;
96030   int arg3 ;
96031
96032   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96033   if (!jarg2) {
96034     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96035     return ;
96036   }
96037   std::string arg2_str(jarg2);
96038   arg2 = &arg2_str;
96039   arg3 = (int)jarg3;
96040   {
96041     try {
96042       (arg1)->Dali::Internal::Adaptor::Widget::OnUpdate((std::string const &)*arg2,arg3);
96043     } catch (std::out_of_range& e) {
96044       {
96045         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96046       };
96047     } catch (std::exception& e) {
96048       {
96049         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96050       };
96051     } catch (...) {
96052       {
96053         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96054       };
96055     }
96056   }
96057 }
96058
96059
96060 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnected(void * jarg1, void * jarg2, void * jarg3) {
96061   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96062   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96063   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96064
96065   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96066   arg2 = (Dali::SlotObserver *)jarg2;
96067   arg3 = (Dali::CallbackBase *)jarg3;
96068   {
96069     try {
96070       (arg1)->SignalConnected(arg2,arg3);
96071     } catch (std::out_of_range& e) {
96072       {
96073         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96074       };
96075     } catch (std::exception& e) {
96076       {
96077         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96078       };
96079     } catch (...) {
96080       {
96081         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96082       };
96083     }
96084   }
96085 }
96086
96087 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalConnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96088   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96089   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96090   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96091
96092   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96093   arg2 = (Dali::SlotObserver *)jarg2;
96094   arg3 = (Dali::CallbackBase *)jarg3;
96095   {
96096     try {
96097       (arg1)->Dali::Internal::Adaptor::Widget::SignalConnected(arg2,arg3);
96098     } catch (std::out_of_range& e) {
96099       {
96100         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96101       };
96102     } catch (std::exception& e) {
96103       {
96104         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96105       };
96106     } catch (...) {
96107       {
96108         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96109       };
96110     }
96111   }
96112 }
96113
96114
96115 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnected(void * jarg1, void * jarg2, void * jarg3) {
96116   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96117   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96118   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96119
96120   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96121   arg2 = (Dali::SlotObserver *)jarg2;
96122   arg3 = (Dali::CallbackBase *)jarg3;
96123   {
96124     try {
96125       (arg1)->SignalDisconnected(arg2,arg3);
96126     } catch (std::out_of_range& e) {
96127       {
96128         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96129       };
96130     } catch (std::exception& e) {
96131       {
96132         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96133       };
96134     } catch (...) {
96135       {
96136         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96137       };
96138     }
96139   }
96140 }
96141
96142 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SignalDisconnectedSwigExplicitWidgetImpl(void * jarg1, void * jarg2, void * jarg3) {
96143   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96144   Dali::SlotObserver *arg2 = (Dali::SlotObserver *) 0 ;
96145   Dali::CallbackBase *arg3 = (Dali::CallbackBase *) 0 ;
96146
96147   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96148   arg2 = (Dali::SlotObserver *)jarg2;
96149   arg3 = (Dali::CallbackBase *)jarg3;
96150   {
96151     try {
96152       (arg1)->Dali::Internal::Adaptor::Widget::SignalDisconnected(arg2,arg3);
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 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetContentInfo(void * jarg1, char * jarg2) {
96170   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96171   std::string *arg2 = 0 ;
96172
96173   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96174   if (!jarg2) {
96175     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96176     return ;
96177   }
96178   std::string arg2_str(jarg2);
96179   arg2 = &arg2_str;
96180   {
96181     try {
96182       (arg1)->SetContentInfo((std::string const &)*arg2);
96183     } catch (std::out_of_range& e) {
96184       {
96185         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96186       };
96187     } catch (std::exception& e) {
96188       {
96189         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96190       };
96191     } catch (...) {
96192       {
96193         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96194       };
96195     }
96196   }
96197 }
96198
96199
96200 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetImpl_SetImpl(void * jarg1, void * jarg2) {
96201   Dali::Internal::Adaptor::Widget *arg1 = (Dali::Internal::Adaptor::Widget *) 0 ;
96202   Dali::Internal::Adaptor::Widget::Impl *arg2 = (Dali::Internal::Adaptor::Widget::Impl *) 0 ;
96203
96204   arg1 = (Dali::Internal::Adaptor::Widget *)jarg1;
96205   arg2 = (Dali::Internal::Adaptor::Widget::Impl *)jarg2;
96206   {
96207     try {
96208       (arg1)->SetImpl(arg2);
96209     } catch (std::out_of_range& e) {
96210       {
96211         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96212       };
96213     } catch (std::exception& e) {
96214       {
96215         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96216       };
96217     } catch (...) {
96218       {
96219         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96220       };
96221     }
96222   }
96223 }
96224
96225 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) {
96226
96227   SwigDirector_WidgetImpl *director = static_cast<SwigDirector_WidgetImpl *>(objarg);
96228   if (director) {
96229     director->swig_connect_director(callback0, callback1, callback2, callback3, callback4, callback5, callback6, callback7);
96230   }
96231 }
96232
96233 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_Widget_GetImplementation__SWIG_0(void * jarg1) {
96234   void * jresult ;
96235   Dali::Widget *arg1 = 0 ;
96236   SwigDirector_WidgetImpl *result = 0 ;
96237
96238   arg1 = (Dali::Widget *)jarg1;
96239   if (!arg1) {
96240     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Widget & type is null", 0);
96241     return 0;
96242   }
96243   {
96244     try {
96245       result = (SwigDirector_WidgetImpl *) &Dali::Internal::Adaptor::GetImplementation(*arg1);
96246     } catch (std::out_of_range& e) {
96247       {
96248         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96249       };
96250     } catch (std::exception& e) {
96251       {
96252         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96253       };
96254     } catch (...) {
96255       {
96256         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96257       };
96258     }
96259   }
96260
96261   jresult = (void *)result;
96262   return jresult;
96263 }
96264
96265
96266 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_New(int jarg1, char * jarg2, char * jarg3) {
96267   void * jresult ;
96268   int *arg1 = (int *) 0 ;
96269   char ***arg2 ;
96270   std::string *arg3 = 0 ;
96271   Dali::WidgetApplication result;
96272   {
96273     int index = 0;
96274     int length = 0;
96275     char *retPtr;
96276     char *nextPtr;
96277     argWidgetC = jarg1;
96278     argWidgetV = new char*[jarg1 + 1];
96279
96280     retPtr = strtok_r( jarg2, " ", &nextPtr);
96281     if( retPtr )
96282     {
96283       length = strlen(retPtr);
96284     }
96285     argWidgetV[index] = new char[length + 1];
96286     if( retPtr )
96287     {
96288       strncpy(argWidgetV[index], retPtr, length);
96289     }
96290     argWidgetV[index][length] = '\0';
96291     index++;
96292
96293     while (index < jarg1)
96294     {
96295       length = 0;
96296       retPtr = strtok_r(NULL, " ", &nextPtr);
96297       if( retPtr )
96298       {
96299         length = strlen(retPtr);
96300       }
96301       argWidgetV[index] = new char[length + 1];
96302       if( retPtr )
96303       {
96304         strncpy(argWidgetV[index], retPtr, length);
96305       }
96306       argWidgetV[index][length] = '\0';
96307       index++;
96308     }
96309
96310     argWidgetV[jarg1] = NULL;
96311     argWidgetC = jarg1;
96312
96313     arg1 = &argWidgetC;
96314     arg2 = &argWidgetV;
96315   }
96316
96317   if (!jarg3) {
96318     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96319     return 0;
96320   }
96321   std::string arg3_str(jarg3);
96322   arg3 = &arg3_str;
96323   {
96324     try {
96325       result = Dali::WidgetApplication::New(arg1,arg2,(std::string const &)*arg3);
96326     } catch (std::out_of_range& e) {
96327       {
96328         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96329       };
96330     } catch (std::exception& e) {
96331       {
96332         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96333       };
96334     } catch (...) {
96335       {
96336         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96337       };
96338     }
96339   }
96340   jresult = new Dali::WidgetApplication((const Dali::WidgetApplication &)result);
96341
96342   return jresult;
96343 }
96344
96345
96346 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_0() {
96347   void * jresult ;
96348   Dali::WidgetApplication *result = 0 ;
96349
96350   {
96351     try {
96352       result = (Dali::WidgetApplication *)new Dali::WidgetApplication();
96353     } catch (std::out_of_range& e) {
96354       {
96355         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96356       };
96357     } catch (std::exception& e) {
96358       {
96359         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96360       };
96361     } catch (...) {
96362       {
96363         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96364       };
96365     }
96366   }
96367   jresult = (void *)result;
96368   return jresult;
96369 }
96370
96371
96372 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WidgetApplication__SWIG_1(void * jarg1) {
96373   void * jresult ;
96374   Dali::WidgetApplication *arg1 = 0 ;
96375   Dali::WidgetApplication *result = 0 ;
96376
96377   arg1 = (Dali::WidgetApplication *)jarg1;
96378   if (!arg1) {
96379     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96380     return 0;
96381   }
96382   {
96383     try {
96384       result = (Dali::WidgetApplication *)new Dali::WidgetApplication((Dali::WidgetApplication const &)*arg1);
96385     } catch (std::out_of_range& e) {
96386       {
96387         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96388       };
96389     } catch (std::exception& e) {
96390       {
96391         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96392       };
96393     } catch (...) {
96394       {
96395         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96396       };
96397     }
96398   }
96399   jresult = (void *)result;
96400   return jresult;
96401 }
96402
96403
96404 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WidgetApplication_Assign(void * jarg1, void * jarg2) {
96405   void * jresult ;
96406   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96407   Dali::WidgetApplication *arg2 = 0 ;
96408   Dali::WidgetApplication *result = 0 ;
96409
96410   arg1 = (Dali::WidgetApplication *)jarg1;
96411   arg2 = (Dali::WidgetApplication *)jarg2;
96412   if (!arg2) {
96413     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::WidgetApplication const & type is null", 0);
96414     return 0;
96415   }
96416   {
96417     try {
96418       result = (Dali::WidgetApplication *) &(arg1)->operator =((Dali::WidgetApplication const &)*arg2);
96419     } catch (std::out_of_range& e) {
96420       {
96421         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96422       };
96423     } catch (std::exception& e) {
96424       {
96425         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96426       };
96427     } catch (...) {
96428       {
96429         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96430       };
96431     }
96432   }
96433   jresult = (void *)result;
96434   return jresult;
96435 }
96436
96437
96438 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WidgetApplication(void * jarg1) {
96439   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96440
96441   arg1 = (Dali::WidgetApplication *)jarg1;
96442   {
96443     try {
96444       delete arg1;
96445       if( argWidgetV )
96446       {
96447         // free string data
96448         for( int i=0; i < argWidgetC+1; i++)
96449         {
96450           delete [] argWidgetV[i];
96451         }
96452         delete [] argWidgetV;
96453       }
96454     } catch (std::out_of_range& e) {
96455       {
96456         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96457       };
96458     } catch (std::exception& e) {
96459       {
96460         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96461       };
96462     } catch (...) {
96463       {
96464         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96465       };
96466     }
96467   }
96468 }
96469
96470
96471 typedef Dali::Widget*(SWIGSTDCALL *CSharpCreateWidgetFunction)(const std::string&);
96472 CSharpCreateWidgetFunction _CSharpCreateWidgetFunction = NULL;
96473
96474 static Dali::Widget SWIGSTDCALL WidgetFactoryFunction( const std::string& widgetName )
96475 {
96476   Widget* widget = _CSharpCreateWidgetFunction( widgetName.c_str() );
96477   return *widget;
96478 }
96479
96480 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WidgetApplication_RegisterWidgetCreatingFunction(void * jarg1, char** jarg2, void * jarg3) {
96481   Dali::WidgetApplication *arg1 = (Dali::WidgetApplication *) 0 ;
96482   std::string *arg2 = 0 ;
96483
96484   arg1 = (Dali::WidgetApplication *)jarg1;
96485   if (!jarg2) {
96486     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
96487     return ;
96488   }
96489   std::string arg2_str(*jarg2);
96490   arg2 = &arg2_str;
96491
96492   if(!_CSharpCreateWidgetFunction)
96493   {
96494     _CSharpCreateWidgetFunction = (Dali::Widget*(*)(const std::string&))jarg3;
96495   }
96496
96497   {
96498     try {
96499       (arg1)->RegisterWidgetCreatingFunction((std::string const &)*arg2, WidgetFactoryFunction);
96500     } catch (std::out_of_range& e) {
96501       {
96502         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96503       };
96504     } catch (std::exception& e) {
96505       {
96506         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96507       };
96508     } catch (...) {
96509       {
96510         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96511       };
96512     }
96513   }
96514
96515   //Typemap argout in c++ file.
96516   //This will convert c++ string to c# string
96517   *jarg2 = SWIG_csharp_string_callback(arg2->c_str());
96518 }
96519
96520
96521 //for PixelBuffer and ImageLoading
96522
96523 SWIGEXPORT Dali::BaseHandle * SWIGSTDCALL CSharp_Dali_PixelBuffer_SWIGUpcast(Dali::Devel::PixelBuffer *jarg1) {
96524     return (Dali::BaseHandle *)jarg1;
96525 }
96526
96527 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_New(unsigned int jarg1, unsigned int jarg2, int jarg3) {
96528   void * jresult ;
96529   unsigned int arg1 ;
96530   unsigned int arg2 ;
96531   Dali::Pixel::Format arg3 ;
96532   Dali::Devel::PixelBuffer result;
96533
96534   arg1 = (unsigned int)jarg1;
96535   arg2 = (unsigned int)jarg2;
96536   arg3 = (Dali::Pixel::Format)jarg3;
96537   {
96538     try {
96539       result = Dali::Devel::PixelBuffer::New(arg1,arg2,arg3);
96540     } catch (std::out_of_range& e) {
96541       {
96542         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96543       };
96544     } catch (std::exception& e) {
96545       {
96546         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96547       };
96548     } catch (...) {
96549       {
96550         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96551       };
96552     }
96553   }
96554   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
96555   return jresult;
96556 }
96557
96558
96559 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_0() {
96560   void * jresult ;
96561   Dali::Devel::PixelBuffer *result = 0 ;
96562
96563   {
96564     try {
96565       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer();
96566     } catch (std::out_of_range& e) {
96567       {
96568         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96569       };
96570     } catch (std::exception& e) {
96571       {
96572         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96573       };
96574     } catch (...) {
96575       {
96576         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96577       };
96578     }
96579   }
96580   jresult = (void *)result;
96581   return jresult;
96582 }
96583
96584
96585 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_PixelBuffer(void * jarg1) {
96586   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96587
96588   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96589   {
96590     try {
96591       delete arg1;
96592     } catch (std::out_of_range& e) {
96593       {
96594         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96595       };
96596     } catch (std::exception& e) {
96597       {
96598         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96599       };
96600     } catch (...) {
96601       {
96602         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96603       };
96604     }
96605   }
96606 }
96607
96608
96609 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_PixelBuffer__SWIG_1(void * jarg1) {
96610   void * jresult ;
96611   Dali::Devel::PixelBuffer *arg1 = 0 ;
96612   Dali::Devel::PixelBuffer *result = 0 ;
96613
96614   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96615   if (!arg1) {
96616     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96617     return 0;
96618   }
96619   {
96620     try {
96621       result = (Dali::Devel::PixelBuffer *)new Dali::Devel::PixelBuffer((Dali::Devel::PixelBuffer const &)*arg1);
96622     } catch (std::out_of_range& e) {
96623       {
96624         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96625       };
96626     } catch (std::exception& e) {
96627       {
96628         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96629       };
96630     } catch (...) {
96631       {
96632         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96633       };
96634     }
96635   }
96636   jresult = (void *)result;
96637   return jresult;
96638 }
96639
96640
96641 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Assign(void * jarg1, void * jarg2) {
96642   void * jresult ;
96643   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96644   Dali::Devel::PixelBuffer *arg2 = 0 ;
96645   Dali::Devel::PixelBuffer *result = 0 ;
96646
96647   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96648   arg2 = (Dali::Devel::PixelBuffer *)jarg2;
96649   if (!arg2) {
96650     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer const & type is null", 0);
96651     return 0;
96652   }
96653   {
96654     try {
96655       result = (Dali::Devel::PixelBuffer *) &(arg1)->operator =((Dali::Devel::PixelBuffer const &)*arg2);
96656     } catch (std::out_of_range& e) {
96657       {
96658         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96659       };
96660     } catch (std::exception& e) {
96661       {
96662         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96663       };
96664     } catch (...) {
96665       {
96666         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96667       };
96668     }
96669   }
96670   jresult = (void *)result;
96671   return jresult;
96672 }
96673
96674
96675 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_Convert(void * jarg1) {
96676   void * jresult ;
96677   Dali::Devel::PixelBuffer *arg1 = 0 ;
96678   Dali::PixelData result;
96679
96680   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96681   if (!arg1) {
96682     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Devel::PixelBuffer & type is null", 0);
96683     return 0;
96684   }
96685   {
96686     try {
96687       result = Dali::Devel::PixelBuffer::Convert(*arg1);
96688     } catch (std::out_of_range& e) {
96689       {
96690         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96691       };
96692     } catch (std::exception& e) {
96693       {
96694         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96695       };
96696     } catch (...) {
96697       {
96698         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96699       };
96700     }
96701   }
96702   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96703   return jresult;
96704 }
96705
96706
96707 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_CreatePixelData(void * jarg1) {
96708   void * jresult ;
96709   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96710   Dali::PixelData result;
96711
96712   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96713   {
96714     try {
96715       result = ((Dali::Devel::PixelBuffer const *)arg1)->CreatePixelData();
96716     } catch (std::out_of_range& e) {
96717       {
96718         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96719       };
96720     } catch (std::exception& e) {
96721       {
96722         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96723       };
96724     } catch (...) {
96725       {
96726         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96727       };
96728     }
96729   }
96730   jresult = new Dali::PixelData((const Dali::PixelData &)result);
96731   return jresult;
96732 }
96733
96734
96735 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_PixelBuffer_GetBuffer(void * jarg1) {
96736   void * jresult ;
96737   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96738   unsigned char *result = 0 ;
96739
96740   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96741   {
96742     try {
96743       result = (unsigned char *)(arg1)->GetBuffer();
96744     } catch (std::out_of_range& e) {
96745       {
96746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96747       };
96748     } catch (std::exception& e) {
96749       {
96750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96751       };
96752     } catch (...) {
96753       {
96754         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96755       };
96756     }
96757   }
96758   jresult = (void *)result;
96759   return jresult;
96760 }
96761
96762
96763 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetWidth(void * jarg1) {
96764   unsigned int jresult ;
96765   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96766   unsigned int result;
96767
96768   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96769   {
96770     try {
96771       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetWidth();
96772     } catch (std::out_of_range& e) {
96773       {
96774         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96775       };
96776     } catch (std::exception& e) {
96777       {
96778         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96779       };
96780     } catch (...) {
96781       {
96782         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96783       };
96784     }
96785   }
96786   jresult = result;
96787   return jresult;
96788 }
96789
96790
96791 SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetHeight(void * jarg1) {
96792   unsigned int jresult ;
96793   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96794   unsigned int result;
96795
96796   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96797   {
96798     try {
96799       result = (unsigned int)((Dali::Devel::PixelBuffer const *)arg1)->GetHeight();
96800     } catch (std::out_of_range& e) {
96801       {
96802         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96803       };
96804     } catch (std::exception& e) {
96805       {
96806         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96807       };
96808     } catch (...) {
96809       {
96810         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96811       };
96812     }
96813   }
96814   jresult = result;
96815   return jresult;
96816 }
96817
96818
96819 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_PixelBuffer_GetPixelFormat(void * jarg1) {
96820   int jresult ;
96821   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96822   Dali::Pixel::Format result;
96823
96824   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96825   {
96826     try {
96827       result = (Dali::Pixel::Format)((Dali::Devel::PixelBuffer const *)arg1)->GetPixelFormat();
96828     } catch (std::out_of_range& e) {
96829       {
96830         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
96831       };
96832     } catch (std::exception& e) {
96833       {
96834         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
96835       };
96836     } catch (...) {
96837       {
96838         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
96839       };
96840     }
96841   }
96842   jresult = (int)result;
96843   return jresult;
96844 }
96845
96846
96847 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_0(void * jarg1, void * jarg2, float jarg3, unsigned int jarg4) {
96848   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96849   Dali::Devel::PixelBuffer arg2 ;
96850   float arg3 ;
96851   bool arg4 ;
96852   Dali::Devel::PixelBuffer *argp2 ;
96853
96854   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96855   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96856   if (!argp2) {
96857     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96858     return ;
96859   }
96860   arg2 = *argp2;
96861   arg3 = (float)jarg3;
96862   arg4 = jarg4 ? true : false;
96863   {
96864     try {
96865       (arg1)->ApplyMask(arg2,arg3,arg4);
96866     } catch (std::out_of_range& e) {
96867       {
96868         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96869       };
96870     } catch (std::exception& e) {
96871       {
96872         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96873       };
96874     } catch (...) {
96875       {
96876         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96877       };
96878     }
96879   }
96880 }
96881
96882
96883 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_1(void * jarg1, void * jarg2, float jarg3) {
96884   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96885   Dali::Devel::PixelBuffer arg2 ;
96886   float arg3 ;
96887   Dali::Devel::PixelBuffer *argp2 ;
96888
96889   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96890   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96891   if (!argp2) {
96892     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96893     return ;
96894   }
96895   arg2 = *argp2;
96896   arg3 = (float)jarg3;
96897   {
96898     try {
96899       (arg1)->ApplyMask(arg2,arg3);
96900     } catch (std::out_of_range& e) {
96901       {
96902         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96903       };
96904     } catch (std::exception& e) {
96905       {
96906         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96907       };
96908     } catch (...) {
96909       {
96910         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96911       };
96912     }
96913   }
96914 }
96915
96916
96917 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyMask__SWIG_2(void * jarg1, void * jarg2) {
96918   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96919   Dali::Devel::PixelBuffer arg2 ;
96920   Dali::Devel::PixelBuffer *argp2 ;
96921
96922   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96923   argp2 = (Dali::Devel::PixelBuffer *)jarg2;
96924   if (!argp2) {
96925     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::Devel::PixelBuffer", 0);
96926     return ;
96927   }
96928   arg2 = *argp2;
96929   {
96930     try {
96931       (arg1)->ApplyMask(arg2);
96932     } catch (std::out_of_range& e) {
96933       {
96934         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96935       };
96936     } catch (std::exception& e) {
96937       {
96938         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96939       };
96940     } catch (...) {
96941       {
96942         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96943       };
96944     }
96945   }
96946 }
96947
96948
96949 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_ApplyGaussianBlur(void * jarg1, float jarg2) {
96950   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96951   float arg2 ;
96952
96953   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96954   arg2 = (float)jarg2;
96955   {
96956     try {
96957       (arg1)->ApplyGaussianBlur(arg2);
96958     } catch (std::out_of_range& e) {
96959       {
96960         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96961       };
96962     } catch (std::exception& e) {
96963       {
96964         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96965       };
96966     } catch (...) {
96967       {
96968         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
96969       };
96970     }
96971   }
96972 }
96973
96974
96975 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Crop(void * jarg1, unsigned short jarg2, unsigned short jarg3, unsigned short jarg4, unsigned short jarg5) {
96976   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
96977   uint16_t arg2 ;
96978   uint16_t arg3 ;
96979   uint16_t arg4 ;
96980   uint16_t arg5 ;
96981
96982   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
96983   arg2 = (uint16_t)jarg2;
96984   arg3 = (uint16_t)jarg3;
96985   arg4 = (uint16_t)jarg4;
96986   arg5 = (uint16_t)jarg5;
96987   {
96988     try {
96989       (arg1)->Crop(arg2,arg3,arg4,arg5);
96990     } catch (std::out_of_range& e) {
96991       {
96992         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
96993       };
96994     } catch (std::exception& e) {
96995       {
96996         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
96997       };
96998     } catch (...) {
96999       {
97000         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97001       };
97002     }
97003   }
97004 }
97005
97006
97007 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_PixelBuffer_Resize(void * jarg1, unsigned short jarg2, unsigned short jarg3) {
97008   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97009   uint16_t arg2 ;
97010   uint16_t arg3 ;
97011
97012   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97013   arg2 = (uint16_t)jarg2;
97014   arg3 = (uint16_t)jarg3;
97015   {
97016     try {
97017       (arg1)->Resize(arg2,arg3);
97018     } catch (std::out_of_range& e) {
97019       {
97020         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97021       };
97022     } catch (std::exception& e) {
97023       {
97024         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97025       };
97026     } catch (...) {
97027       {
97028         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97029       };
97030     }
97031   }
97032 }
97033
97034 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_PixelBuffer_Rotate(void * jarg1, void * jarg2) {
97035   Dali::Devel::PixelBuffer *arg1 = (Dali::Devel::PixelBuffer *) 0 ;
97036   Dali::Degree * arg2 ;
97037
97038   bool result = false;
97039
97040   arg1 = (Dali::Devel::PixelBuffer *)jarg1;
97041   arg2 = (Dali::Degree *)jarg2;
97042   {
97043     try {
97044       result = (arg1)->Rotate(*arg2);
97045     } catch (std::out_of_range& e) {
97046       {
97047         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
97048       };
97049     } catch (std::exception& e) {
97050       {
97051         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
97052       };
97053     } catch (...) {
97054       {
97055         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
97056       };
97057     }
97058   }
97059   return result;
97060 }
97061
97062
97063 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97064   void * jresult ;
97065   std::string *arg1 = 0 ;
97066   Dali::ImageDimensions arg2 ;
97067   Dali::FittingMode::Type arg3 ;
97068   Dali::SamplingMode::Type arg4 ;
97069   bool arg5 ;
97070   Dali::ImageDimensions *argp2 ;
97071   Dali::Devel::PixelBuffer result;
97072
97073   if (!jarg1) {
97074     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97075     return 0;
97076   }
97077   std::string arg1_str(jarg1);
97078   arg1 = &arg1_str;
97079   argp2 = (Dali::ImageDimensions *)jarg2;
97080   if (!argp2) {
97081     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97082     return 0;
97083   }
97084   arg2 = *argp2;
97085   arg3 = (Dali::FittingMode::Type)jarg3;
97086   arg4 = (Dali::SamplingMode::Type)jarg4;
97087   arg5 = jarg5 ? true : false;
97088   {
97089     try {
97090       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97091     } catch (std::out_of_range& e) {
97092       {
97093         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97094       };
97095     } catch (std::exception& e) {
97096       {
97097         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97098       };
97099     } catch (...) {
97100       {
97101         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97102       };
97103     }
97104   }
97105   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97106
97107   return jresult;
97108 }
97109
97110
97111 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97112   void * jresult ;
97113   std::string *arg1 = 0 ;
97114   Dali::ImageDimensions arg2 ;
97115   Dali::FittingMode::Type arg3 ;
97116   Dali::SamplingMode::Type arg4 ;
97117   Dali::ImageDimensions *argp2 ;
97118   Dali::Devel::PixelBuffer result;
97119
97120   if (!jarg1) {
97121     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97122     return 0;
97123   }
97124   std::string arg1_str(jarg1);
97125   arg1 = &arg1_str;
97126   argp2 = (Dali::ImageDimensions *)jarg2;
97127   if (!argp2) {
97128     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97129     return 0;
97130   }
97131   arg2 = *argp2;
97132   arg3 = (Dali::FittingMode::Type)jarg3;
97133   arg4 = (Dali::SamplingMode::Type)jarg4;
97134   {
97135     try {
97136       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3,arg4);
97137     } catch (std::out_of_range& e) {
97138       {
97139         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97140       };
97141     } catch (std::exception& e) {
97142       {
97143         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97144       };
97145     } catch (...) {
97146       {
97147         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97148       };
97149     }
97150   }
97151   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97152
97153   return jresult;
97154 }
97155
97156
97157 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97158   void * jresult ;
97159   std::string *arg1 = 0 ;
97160   Dali::ImageDimensions arg2 ;
97161   Dali::FittingMode::Type arg3 ;
97162   Dali::ImageDimensions *argp2 ;
97163   Dali::Devel::PixelBuffer result;
97164
97165   if (!jarg1) {
97166     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97167     return 0;
97168   }
97169   std::string arg1_str(jarg1);
97170   arg1 = &arg1_str;
97171   argp2 = (Dali::ImageDimensions *)jarg2;
97172   if (!argp2) {
97173     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97174     return 0;
97175   }
97176   arg2 = *argp2;
97177   arg3 = (Dali::FittingMode::Type)jarg3;
97178   {
97179     try {
97180       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2,arg3);
97181     } catch (std::out_of_range& e) {
97182       {
97183         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97184       };
97185     } catch (std::exception& e) {
97186       {
97187         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97188       };
97189     } catch (...) {
97190       {
97191         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97192       };
97193     }
97194   }
97195   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97196
97197   return jresult;
97198 }
97199
97200
97201 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_3(char * jarg1, void * jarg2) {
97202   void * jresult ;
97203   std::string *arg1 = 0 ;
97204   Dali::ImageDimensions arg2 ;
97205   Dali::ImageDimensions *argp2 ;
97206   Dali::Devel::PixelBuffer result;
97207
97208   if (!jarg1) {
97209     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97210     return 0;
97211   }
97212   std::string arg1_str(jarg1);
97213   arg1 = &arg1_str;
97214   argp2 = (Dali::ImageDimensions *)jarg2;
97215   if (!argp2) {
97216     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97217     return 0;
97218   }
97219   arg2 = *argp2;
97220   {
97221     try {
97222       result = Dali::LoadImageFromFile((std::string const &)*arg1,arg2);
97223     } catch (std::out_of_range& e) {
97224       {
97225         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97226       };
97227     } catch (std::exception& e) {
97228       {
97229         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97230       };
97231     } catch (...) {
97232       {
97233         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97234       };
97235     }
97236   }
97237   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97238
97239   return jresult;
97240 }
97241
97242
97243 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_LoadImageFromFile__SWIG_4(char * jarg1) {
97244   void * jresult ;
97245   std::string *arg1 = 0 ;
97246   Dali::Devel::PixelBuffer result;
97247
97248   if (!jarg1) {
97249     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97250     return 0;
97251   }
97252   std::string arg1_str(jarg1);
97253   arg1 = &arg1_str;
97254   {
97255     try {
97256       result = Dali::LoadImageFromFile((std::string const &)*arg1);
97257     } catch (std::out_of_range& e) {
97258       {
97259         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97260       };
97261     } catch (std::exception& e) {
97262       {
97263         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97264       };
97265     } catch (...) {
97266       {
97267         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97268       };
97269     }
97270   }
97271   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97272
97273   return jresult;
97274 }
97275
97276
97277 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97278   void * jresult ;
97279   std::string *arg1 = 0 ;
97280   Dali::ImageDimensions arg2 ;
97281   Dali::FittingMode::Type arg3 ;
97282   Dali::SamplingMode::Type arg4 ;
97283   bool arg5 ;
97284   Dali::ImageDimensions *argp2 ;
97285   Dali::ImageDimensions result;
97286
97287   if (!jarg1) {
97288     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97289     return 0;
97290   }
97291   std::string arg1_str(jarg1);
97292   arg1 = &arg1_str;
97293   argp2 = (Dali::ImageDimensions *)jarg2;
97294   if (!argp2) {
97295     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97296     return 0;
97297   }
97298   arg2 = *argp2;
97299   arg3 = (Dali::FittingMode::Type)jarg3;
97300   arg4 = (Dali::SamplingMode::Type)jarg4;
97301   arg5 = jarg5 ? true : false;
97302   {
97303     try {
97304       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97305     } catch (std::out_of_range& e) {
97306       {
97307         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97308       };
97309     } catch (std::exception& e) {
97310       {
97311         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97312       };
97313     } catch (...) {
97314       {
97315         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97316       };
97317     }
97318   }
97319   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97320
97321   return jresult;
97322 }
97323
97324
97325 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97326   void * jresult ;
97327   std::string *arg1 = 0 ;
97328   Dali::ImageDimensions arg2 ;
97329   Dali::FittingMode::Type arg3 ;
97330   Dali::SamplingMode::Type arg4 ;
97331   Dali::ImageDimensions *argp2 ;
97332   Dali::ImageDimensions result;
97333
97334   if (!jarg1) {
97335     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97336     return 0;
97337   }
97338   std::string arg1_str(jarg1);
97339   arg1 = &arg1_str;
97340   argp2 = (Dali::ImageDimensions *)jarg2;
97341   if (!argp2) {
97342     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97343     return 0;
97344   }
97345   arg2 = *argp2;
97346   arg3 = (Dali::FittingMode::Type)jarg3;
97347   arg4 = (Dali::SamplingMode::Type)jarg4;
97348   {
97349     try {
97350       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3,arg4);
97351     } catch (std::out_of_range& e) {
97352       {
97353         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97354       };
97355     } catch (std::exception& e) {
97356       {
97357         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97358       };
97359     } catch (...) {
97360       {
97361         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97362       };
97363     }
97364   }
97365   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97366
97367   return jresult;
97368 }
97369
97370
97371 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97372   void * jresult ;
97373   std::string *arg1 = 0 ;
97374   Dali::ImageDimensions arg2 ;
97375   Dali::FittingMode::Type arg3 ;
97376   Dali::ImageDimensions *argp2 ;
97377   Dali::ImageDimensions result;
97378
97379   if (!jarg1) {
97380     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97381     return 0;
97382   }
97383   std::string arg1_str(jarg1);
97384   arg1 = &arg1_str;
97385   argp2 = (Dali::ImageDimensions *)jarg2;
97386   if (!argp2) {
97387     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97388     return 0;
97389   }
97390   arg2 = *argp2;
97391   arg3 = (Dali::FittingMode::Type)jarg3;
97392   {
97393     try {
97394       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2,arg3);
97395     } catch (std::out_of_range& e) {
97396       {
97397         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97398       };
97399     } catch (std::exception& e) {
97400       {
97401         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97402       };
97403     } catch (...) {
97404       {
97405         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97406       };
97407     }
97408   }
97409   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97410
97411   return jresult;
97412 }
97413
97414
97415 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_3(char * jarg1, void * jarg2) {
97416   void * jresult ;
97417   std::string *arg1 = 0 ;
97418   Dali::ImageDimensions arg2 ;
97419   Dali::ImageDimensions *argp2 ;
97420   Dali::ImageDimensions result;
97421
97422   if (!jarg1) {
97423     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97424     return 0;
97425   }
97426   std::string arg1_str(jarg1);
97427   arg1 = &arg1_str;
97428   argp2 = (Dali::ImageDimensions *)jarg2;
97429   if (!argp2) {
97430     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97431     return 0;
97432   }
97433   arg2 = *argp2;
97434   {
97435     try {
97436       result = Dali::GetClosestImageSize((std::string const &)*arg1,arg2);
97437     } catch (std::out_of_range& e) {
97438       {
97439         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97440       };
97441     } catch (std::exception& e) {
97442       {
97443         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97444       };
97445     } catch (...) {
97446       {
97447         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97448       };
97449     }
97450   }
97451   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97452
97453   return jresult;
97454 }
97455
97456
97457 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetClosestImageSize__SWIG_4(char * jarg1) {
97458   void * jresult ;
97459   std::string *arg1 = 0 ;
97460   Dali::ImageDimensions result;
97461
97462   if (!jarg1) {
97463     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97464     return 0;
97465   }
97466   std::string arg1_str(jarg1);
97467   arg1 = &arg1_str;
97468   {
97469     try {
97470       result = Dali::GetClosestImageSize((std::string const &)*arg1);
97471     } catch (std::out_of_range& e) {
97472       {
97473         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97474       };
97475     } catch (std::exception& e) {
97476       {
97477         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97478       };
97479     } catch (...) {
97480       {
97481         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97482       };
97483     }
97484   }
97485   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97486
97487   return jresult;
97488 }
97489
97490 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_GetOriginalImageSize(char * jarg1) {
97491   void * jresult ;
97492   std::string *arg1 = 0 ;
97493   Dali::ImageDimensions result;
97494
97495   if (!jarg1) {
97496     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97497     return 0;
97498   }
97499   std::string arg1_str(jarg1);
97500   arg1 = &arg1_str;
97501   {
97502     try {
97503       result = Dali::GetOriginalImageSize((std::string const &)*arg1);
97504     } catch (std::out_of_range& e) {
97505       {
97506         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97507       };
97508     } catch (std::exception& e) {
97509       {
97510         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97511       };
97512     } catch (...) {
97513       {
97514         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97515       };
97516     }
97517   }
97518   jresult = new Dali::ImageDimensions((const Dali::ImageDimensions &)result);
97519
97520   return jresult;
97521 }
97522
97523 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_0(char * jarg1, void * jarg2, int jarg3, int jarg4, unsigned int jarg5) {
97524   void * jresult ;
97525   std::string *arg1 = 0 ;
97526   Dali::ImageDimensions arg2 ;
97527   Dali::FittingMode::Type arg3 ;
97528   Dali::SamplingMode::Type arg4 ;
97529   bool arg5 ;
97530   Dali::ImageDimensions *argp2 ;
97531   Dali::Devel::PixelBuffer result;
97532
97533   if (!jarg1) {
97534     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97535     return 0;
97536   }
97537   std::string arg1_str(jarg1);
97538   arg1 = &arg1_str;
97539   argp2 = (Dali::ImageDimensions *)jarg2;
97540   if (!argp2) {
97541     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97542     return 0;
97543   }
97544   arg2 = *argp2;
97545   arg3 = (Dali::FittingMode::Type)jarg3;
97546   arg4 = (Dali::SamplingMode::Type)jarg4;
97547   arg5 = jarg5 ? true : false;
97548   {
97549     try {
97550       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4,arg5);
97551     } catch (std::out_of_range& e) {
97552       {
97553         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97554       };
97555     } catch (std::exception& e) {
97556       {
97557         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97558       };
97559     } catch (...) {
97560       {
97561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97562       };
97563     }
97564   }
97565   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97566
97567   return jresult;
97568 }
97569
97570
97571 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_1(char * jarg1, void * jarg2, int jarg3, int jarg4) {
97572   void * jresult ;
97573   std::string *arg1 = 0 ;
97574   Dali::ImageDimensions arg2 ;
97575   Dali::FittingMode::Type arg3 ;
97576   Dali::SamplingMode::Type arg4 ;
97577   Dali::ImageDimensions *argp2 ;
97578   Dali::Devel::PixelBuffer result;
97579
97580   if (!jarg1) {
97581     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97582     return 0;
97583   }
97584   std::string arg1_str(jarg1);
97585   arg1 = &arg1_str;
97586   argp2 = (Dali::ImageDimensions *)jarg2;
97587   if (!argp2) {
97588     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97589     return 0;
97590   }
97591   arg2 = *argp2;
97592   arg3 = (Dali::FittingMode::Type)jarg3;
97593   arg4 = (Dali::SamplingMode::Type)jarg4;
97594   {
97595     try {
97596       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3,arg4);
97597     } catch (std::out_of_range& e) {
97598       {
97599         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97600       };
97601     } catch (std::exception& e) {
97602       {
97603         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97604       };
97605     } catch (...) {
97606       {
97607         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97608       };
97609     }
97610   }
97611   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97612
97613   return jresult;
97614 }
97615
97616
97617 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_2(char * jarg1, void * jarg2, int jarg3) {
97618   void * jresult ;
97619   std::string *arg1 = 0 ;
97620   Dali::ImageDimensions arg2 ;
97621   Dali::FittingMode::Type arg3 ;
97622   Dali::ImageDimensions *argp2 ;
97623   Dali::Devel::PixelBuffer result;
97624
97625   if (!jarg1) {
97626     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97627     return 0;
97628   }
97629   std::string arg1_str(jarg1);
97630   arg1 = &arg1_str;
97631   argp2 = (Dali::ImageDimensions *)jarg2;
97632   if (!argp2) {
97633     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97634     return 0;
97635   }
97636   arg2 = *argp2;
97637   arg3 = (Dali::FittingMode::Type)jarg3;
97638   {
97639     try {
97640       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2,arg3);
97641     } catch (std::out_of_range& e) {
97642       {
97643         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97644       };
97645     } catch (std::exception& e) {
97646       {
97647         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97648       };
97649     } catch (...) {
97650       {
97651         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97652       };
97653     }
97654   }
97655   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97656
97657   return jresult;
97658 }
97659
97660
97661 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_3(char * jarg1, void * jarg2) {
97662   void * jresult ;
97663   std::string *arg1 = 0 ;
97664   Dali::ImageDimensions arg2 ;
97665   Dali::ImageDimensions *argp2 ;
97666   Dali::Devel::PixelBuffer result;
97667
97668   if (!jarg1) {
97669     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97670     return 0;
97671   }
97672   std::string arg1_str(jarg1);
97673   arg1 = &arg1_str;
97674   argp2 = (Dali::ImageDimensions *)jarg2;
97675   if (!argp2) {
97676     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::ImageDimensions", 0);
97677     return 0;
97678   }
97679   arg2 = *argp2;
97680   {
97681     try {
97682       result = Dali::DownloadImageSynchronously((std::string const &)*arg1,arg2);
97683     } catch (std::out_of_range& e) {
97684       {
97685         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97686       };
97687     } catch (std::exception& e) {
97688       {
97689         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97690       };
97691     } catch (...) {
97692       {
97693         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97694       };
97695     }
97696   }
97697   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97698
97699   return jresult;
97700 }
97701
97702
97703 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_DownloadImageSynchronously__SWIG_4(char * jarg1) {
97704   void * jresult ;
97705   std::string *arg1 = 0 ;
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   {
97715     try {
97716       result = Dali::DownloadImageSynchronously((std::string const &)*arg1);
97717     } catch (std::out_of_range& e) {
97718       {
97719         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97720       };
97721     } catch (std::exception& e) {
97722       {
97723         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97724       };
97725     } catch (...) {
97726       {
97727         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97728       };
97729     }
97730   }
97731   jresult = new Dali::Devel::PixelBuffer((const Dali::Devel::PixelBuffer &)result);
97732
97733   return jresult;
97734 }
97735
97736
97737 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New() {
97738   void * jresult ;
97739   Dali::Toolkit::WebView result;
97740
97741   {
97742     try {
97743       result = Dali::Toolkit::WebView::New();
97744     } catch (std::out_of_range& e) {
97745       {
97746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97747       };
97748     } catch (std::exception& e) {
97749       {
97750         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97751       };
97752     } catch (Dali::DaliException e) {
97753       {
97754         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97755       };
97756     } catch (...) {
97757       {
97758         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97759       };
97760     }
97761   }
97762   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97763   return jresult;
97764 }
97765
97766 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_New_2(char * jarg1, char * jarg2) {
97767   void * jresult ;
97768   Dali::Toolkit::WebView result;
97769
97770   std::string *arg1;
97771   std::string *arg2;
97772
97773   if (!jarg1) {
97774     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg1 is null string", 0);
97775     return 0;
97776   }
97777   if (!jarg2) {
97778     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "jarg2 is null string", 0);
97779     return 0;
97780   }
97781
97782   std::string jarg1_str = std::string(jarg1);
97783   std::string jarg2_str = std::string(jarg2);
97784
97785   arg1 = &jarg1_str;
97786   arg2 = &jarg2_str;
97787
97788   {
97789     try {
97790       result = Dali::Toolkit::WebView::New( (std::string const &)*arg1, (std::string const &)*arg2);
97791     } catch (std::out_of_range& e) {
97792       {
97793         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97794       };
97795     } catch (std::exception& e) {
97796       {
97797         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97798       };
97799     } catch (Dali::DaliException e) {
97800       {
97801         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97802       };
97803     } catch (...) {
97804       {
97805         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97806       };
97807     }
97808   }
97809   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97810   return jresult;
97811 }
97812
97813 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebView__SWIG_1(void * jarg1) {
97814   void * jresult ;
97815   Dali::Toolkit::WebView *arg1 = 0 ;
97816   Dali::Toolkit::WebView *result = 0 ;
97817
97818   arg1 = (Dali::Toolkit::WebView *)jarg1;
97819   if (!arg1) {
97820     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97821     return 0;
97822   }
97823   {
97824     try {
97825       result = (Dali::Toolkit::WebView *)new Dali::Toolkit::WebView((Dali::Toolkit::WebView const &)*arg1);
97826     } catch (std::out_of_range& e) {
97827       {
97828         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97829       };
97830     } catch (std::exception& e) {
97831       {
97832         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97833       };
97834     } catch (Dali::DaliException e) {
97835       {
97836         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97837       };
97838     } catch (...) {
97839       {
97840         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97841       };
97842     }
97843   }
97844   jresult = (void *)result;
97845   return jresult;
97846 }
97847
97848 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebView(void * jarg1) {
97849   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97850   arg1 = (Dali::Toolkit::WebView *)jarg1;
97851   {
97852     try {
97853       delete arg1;
97854     } catch (std::out_of_range& e) {
97855       {
97856         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97857       };
97858     } catch (std::exception& e) {
97859       {
97860         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
97861       };
97862     } catch (Dali::DaliException e) {
97863       {
97864         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
97865       };
97866     } catch (...) {
97867       {
97868         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
97869       };
97870     }
97871   }
97872 }
97873
97874 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_Assign(void * jarg1, void * jarg2) {
97875   void * jresult ;
97876   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97877   Dali::Toolkit::WebView *arg2 = 0 ;
97878   Dali::Toolkit::WebView *result = 0 ;
97879
97880   arg1 = (Dali::Toolkit::WebView *)jarg1;
97881   arg2 = (Dali::Toolkit::WebView *)jarg2;
97882   if (!arg2) {
97883     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Dali::Toolkit::WebView const & type is null", 0);
97884     return 0;
97885   }
97886   {
97887     try {
97888       result = (Dali::Toolkit::WebView *) &(arg1)->operator =((Dali::Toolkit::WebView const &)*arg2);
97889     } catch (std::out_of_range& e) {
97890       {
97891         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97892       };
97893     } catch (std::exception& e) {
97894       {
97895         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97896       };
97897     } catch (Dali::DaliException e) {
97898       {
97899         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97900       };
97901     } catch (...) {
97902       {
97903         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97904       };
97905     }
97906   }
97907   jresult = (void *)result;
97908   return jresult;
97909 }
97910
97911 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_WebView_DownCast(void * jarg1) {
97912   void * jresult ;
97913   Dali::BaseHandle arg1 ;
97914   Dali::BaseHandle *argp1 ;
97915   Dali::Toolkit::WebView result;
97916
97917   argp1 = (Dali::BaseHandle *)jarg1;
97918   if (!argp1) {
97919     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "Attempt to dereference null Dali::BaseHandle", 0);
97920     return 0;
97921   }
97922   arg1 = *argp1;
97923   {
97924     try {
97925       result = Dali::Toolkit::WebView::DownCast(arg1);
97926     } catch (std::out_of_range& e) {
97927       {
97928         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
97929       };
97930     } catch (std::exception& e) {
97931       {
97932         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
97933       };
97934     } catch (Dali::DaliException e) {
97935       {
97936         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
97937       };
97938     } catch (...) {
97939       {
97940         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
97941       };
97942     }
97943   }
97944   jresult = new Dali::Toolkit::WebView((const Dali::Toolkit::WebView &)result);
97945   return jresult;
97946 }
97947
97948 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_URL_get() {
97949   return (int) Dali::Toolkit::WebView::Property::URL;
97950 }
97951
97952 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_CACHE_MODEL_get() {
97953   return (int) Dali::Toolkit::WebView::Property::CACHE_MODEL;
97954 }
97955
97956 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_COOKIE_ACCEPT_POLICY_get() {
97957   return (int) Dali::Toolkit::WebView::Property::COOKIE_ACCEPT_POLICY;
97958 }
97959
97960 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_USER_AGENT_get() {
97961   return (int) Dali::Toolkit::WebView::Property::USER_AGENT;
97962 }
97963
97964 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_ENABLE_JAVASCRIPT_get() {
97965   return (int) Dali::Toolkit::WebView::Property::ENABLE_JAVASCRIPT;
97966 }
97967
97968 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_LOAD_IMAGES_AUTOMATICALLY_get() {
97969   return (int) Dali::Toolkit::WebView::Property::LOAD_IMAGES_AUTOMATICALLY;
97970 }
97971
97972 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_TEXT_ENCODING_NAME_get() {
97973   return (int) Dali::Toolkit::WebView::Property::DEFAULT_TEXT_ENCODING_NAME;
97974 }
97975
97976 SWIGEXPORT int SWIGSTDCALL CSharp_Dali_WebView_Property_DEFAULT_FONT_SIZE_get() {
97977   return (int) Dali::Toolkit::WebView::Property::DEFAULT_FONT_SIZE;
97978 }
97979
97980 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadUrl(void * jarg1, char * jarg2) {
97981   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
97982   std::string *arg2;
97983
97984   arg1 = (Dali::Toolkit::WebView *)jarg1;
97985
97986   if (!jarg2) {
97987     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
97988     return;
97989   }
97990
97991   std::string jarg2str = std::string(jarg2);
97992   arg2 = &jarg2str;
97993   {
97994     try {
97995       (arg1)->LoadUrl((std::string const &)*arg2);
97996     } catch (std::out_of_range& e) {
97997       {
97998         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
97999       };
98000     } catch (std::exception& e) {
98001       {
98002         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98003       };
98004     } catch (Dali::DaliException e) {
98005       {
98006         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98007       };
98008     } catch (...) {
98009       {
98010         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98011       };
98012     }
98013   }
98014 }
98015
98016 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_LoadHTMLString(void * jarg1, char * jarg2) {
98017   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98018   std::string *arg2;
98019
98020   arg1 = (Dali::Toolkit::WebView *)jarg1;
98021   if (!jarg2) {
98022     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98023     return;
98024   }
98025   std::string jarg2str = std::string(jarg2);
98026   arg2 = &jarg2str;
98027   {
98028     try {
98029       (arg1)->LoadHTMLString((std::string const &)*arg2);
98030     } catch (std::out_of_range& e) {
98031       {
98032         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98033       };
98034     } catch (std::exception& e) {
98035       {
98036         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98037       };
98038     } catch (Dali::DaliException e) {
98039       {
98040         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98041       };
98042     } catch (...) {
98043       {
98044         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98045       };
98046     }
98047   }
98048 }
98049
98050 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Reload(void * jarg1) {
98051   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98052
98053   arg1 = (Dali::Toolkit::WebView *)jarg1;
98054   {
98055     try {
98056       (arg1)->Reload();
98057     } catch (std::out_of_range& e) {
98058       {
98059         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98060       };
98061     } catch (std::exception& e) {
98062       {
98063         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98064       };
98065     } catch (Dali::DaliException e) {
98066       {
98067         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98068       };
98069     } catch (...) {
98070       {
98071         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98072       };
98073     }
98074   }
98075 }
98076
98077 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_StopLoading(void * jarg1) {
98078   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98079
98080   arg1 = (Dali::Toolkit::WebView *)jarg1;
98081   {
98082     try {
98083       (arg1)->StopLoading();
98084     } catch (std::out_of_range& e) {
98085       {
98086         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98087       };
98088     } catch (std::exception& e) {
98089       {
98090         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98091       };
98092     } catch (Dali::DaliException e) {
98093       {
98094         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98095       };
98096     } catch (...) {
98097       {
98098         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98099       };
98100     }
98101   }
98102 }
98103
98104 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Suspend(void * jarg1) {
98105   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98106
98107   arg1 = (Dali::Toolkit::WebView *)jarg1;
98108   {
98109     try {
98110       (arg1)->Suspend();
98111     } catch (std::out_of_range& e) {
98112       {
98113         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98114       };
98115     } catch (std::exception& e) {
98116       {
98117         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98118       };
98119     } catch (Dali::DaliException e) {
98120       {
98121         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98122       };
98123     } catch (...) {
98124       {
98125         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98126       };
98127     }
98128   }
98129 }
98130
98131 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_Resume(void * jarg1) {
98132   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98133
98134   arg1 = (Dali::Toolkit::WebView *)jarg1;
98135   {
98136     try {
98137       (arg1)->Resume();
98138     } catch (std::out_of_range& e) {
98139       {
98140         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98141       };
98142     } catch (std::exception& e) {
98143       {
98144         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98145       };
98146     } catch (Dali::DaliException e) {
98147       {
98148         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98149       };
98150     } catch (...) {
98151       {
98152         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98153       };
98154     }
98155   }
98156 }
98157
98158 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoBack(void * jarg1) {
98159   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98160
98161   arg1 = (Dali::Toolkit::WebView *)jarg1;
98162   {
98163     try {
98164       (arg1)->GoBack();
98165     } catch (std::out_of_range& e) {
98166       {
98167         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98168       };
98169     } catch (std::exception& e) {
98170       {
98171         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98172       };
98173     } catch (Dali::DaliException e) {
98174       {
98175         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98176       };
98177     } catch (...) {
98178       {
98179         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98180       };
98181     }
98182   }
98183 }
98184
98185 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_GoForward(void * jarg1) {
98186   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98187
98188   arg1 = (Dali::Toolkit::WebView *)jarg1;
98189   {
98190     try {
98191       (arg1)->GoForward();
98192     } catch (std::out_of_range& e) {
98193       {
98194         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98195       };
98196     } catch (std::exception& e) {
98197       {
98198         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98199       };
98200     } catch (Dali::DaliException e) {
98201       {
98202         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98203       };
98204     } catch (...) {
98205       {
98206         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98207       };
98208     }
98209   }
98210 }
98211
98212 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoBack(void * jarg1) {
98213   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98214   bool ret;
98215
98216   arg1 = (Dali::Toolkit::WebView *)jarg1;
98217   {
98218     try {
98219       ret = (arg1)->CanGoBack();
98220     } catch (std::out_of_range& e) {
98221       {
98222         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98223       };
98224     } catch (std::exception& e) {
98225       {
98226         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98227       };
98228     } catch (Dali::DaliException e) {
98229       {
98230         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98231       };
98232     } catch (...) {
98233       {
98234         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98235       };
98236     }
98237   }
98238   return ret;
98239 }
98240
98241 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_WebView_CanGoForward(void * jarg1) {
98242   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98243   bool ret;
98244
98245   arg1 = (Dali::Toolkit::WebView *)jarg1;
98246   {
98247     try {
98248       ret = (arg1)->CanGoForward();
98249     } catch (std::out_of_range& e) {
98250       {
98251         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return false;
98252       };
98253     } catch (std::exception& e) {
98254       {
98255         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return false;
98256       };
98257     } catch (Dali::DaliException e) {
98258       {
98259         SWIG_CSharpException(SWIG_UnknownError, e.condition); return false;
98260       };
98261     } catch (...) {
98262       {
98263         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return false;
98264       };
98265     }
98266   }
98267   return ret;
98268 }
98269
98270 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_EvaluateJavaScript(void * jarg1, char * jarg2, void* jarg3) {
98271   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98272   std::string *arg2;
98273
98274   arg1 = (Dali::Toolkit::WebView *)jarg1;
98275   if (!jarg2) {
98276     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98277     return;
98278   }
98279   std::string jarg2_str = std::string(jarg2);
98280   arg2 = &jarg2_str;
98281
98282   {
98283     try {
98284       if (jarg3) {
98285         void (*handler)(char*) = (void (*)(char*)) jarg3;
98286         (arg1)->EvaluateJavaScript((std::string const &)*arg2, [handler](const std::string& result) {
98287           handler(SWIG_csharp_string_callback(result.c_str()));
98288         });
98289       } else {
98290         (arg1)->EvaluateJavaScript((std::string const &)*arg2);
98291       }
98292     } catch (std::out_of_range& e) {
98293       {
98294         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98295       };
98296     } catch (std::exception& e) {
98297       {
98298         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98299       };
98300     } catch (Dali::DaliException e) {
98301       {
98302         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98303       };
98304     } catch (...) {
98305       {
98306         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98307       };
98308     }
98309   }
98310 }
98311
98312 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_AddJavaScriptMessageHandler(void* jarg1, char* jarg2, void* jarg3)
98313 {
98314   if (!jarg2) {
98315     SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "null string", 0);
98316     return;
98317   }
98318
98319   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98320   std::string exposedObjectName = jarg2;
98321   void (*handler)(char*) = (void (*)(char*)) jarg3;
98322
98323   {
98324     try {
98325       webview->AddJavaScriptMessageHandler(exposedObjectName, [handler](const std::string& message) {
98326         handler(SWIG_csharp_string_callback(message.c_str()));
98327       });
98328     } catch (std::out_of_range& e) {
98329       {
98330         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98331       };
98332     } catch (std::exception& e) {
98333       {
98334         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98335       };
98336     } catch (Dali::DaliException e) {
98337       {
98338         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98339       };
98340     } catch (...) {
98341       {
98342         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98343       };
98344     }
98345   }
98346 }
98347
98348 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearHistory(void * jarg1) {
98349   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98350
98351   arg1 = (Dali::Toolkit::WebView *)jarg1;
98352   {
98353     try {
98354       (arg1)->ClearHistory();
98355     } catch (std::out_of_range& e) {
98356       {
98357         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98358       };
98359     } catch (std::exception& e) {
98360       {
98361         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98362       };
98363     } catch (Dali::DaliException e) {
98364       {
98365         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98366       };
98367     } catch (...) {
98368       {
98369         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98370       };
98371     }
98372   }
98373 }
98374
98375 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCache(void * jarg1) {
98376   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98377
98378   arg1 = (Dali::Toolkit::WebView *)jarg1;
98379   {
98380     try {
98381       (arg1)->ClearCache();
98382     } catch (std::out_of_range& e) {
98383       {
98384         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98385       };
98386     } catch (std::exception& e) {
98387       {
98388         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98389       };
98390     } catch (Dali::DaliException e) {
98391       {
98392         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98393       };
98394     } catch (...) {
98395       {
98396         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98397       };
98398     }
98399   }
98400 }
98401
98402 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebView_ClearCookies(void * jarg1) {
98403   Dali::Toolkit::WebView *arg1 = (Dali::Toolkit::WebView *) 0 ;
98404
98405   arg1 = (Dali::Toolkit::WebView *)jarg1;
98406   {
98407     try {
98408       (arg1)->ClearCookies();
98409     } catch (std::out_of_range& e) {
98410       {
98411         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98412       };
98413     } catch (std::exception& e) {
98414       {
98415         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98416       };
98417     } catch (Dali::DaliException e) {
98418       {
98419         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98420       };
98421     } catch (...) {
98422       {
98423         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98424       };
98425     }
98426   }
98427 }
98428
98429 SWIGEXPORT Dali::Toolkit::Control * SWIGSTDCALL CSharp_Dali_WebView_SWIGUpcast(Dali::Toolkit::WebView *jarg1) {
98430     return (Dali::Toolkit::Control *)jarg1;
98431 }
98432
98433 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadStarted(void * jarg1) {
98434   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98435   SignalConverter::WebViewPageLoadSignal* result = NULL;
98436   {
98437     try {
98438       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadStartedSignal());
98439     } catch (std::out_of_range& e) {
98440       {
98441         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98442       };
98443     } catch (std::exception& e) {
98444       {
98445         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98446       };
98447     } catch (Dali::DaliException e) {
98448       {
98449         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98450       };
98451     } catch (...) {
98452       {
98453         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98454       };
98455     }
98456   }
98457   return (void*) result;
98458 }
98459
98460 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadSignal_PageLoadFinished(void * jarg1) {
98461   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98462   SignalConverter::WebViewPageLoadSignal* result = NULL;
98463   {
98464     try {
98465       result = new SignalConverter::WebViewPageLoadSignal(&webview->PageLoadFinishedSignal());
98466     } catch (std::out_of_range& e) {
98467       {
98468         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98469       };
98470     } catch (std::exception& e) {
98471       {
98472         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98473       };
98474     } catch (Dali::DaliException e) {
98475       {
98476         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98477       };
98478     } catch (...) {
98479       {
98480         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98481       };
98482     }
98483   }
98484   return (void*) result;
98485 }
98486
98487 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadSignal(void * jarg1)
98488 {
98489   SignalConverter::WebViewPageLoadSignal* object = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98490   {
98491     try {
98492       delete object;
98493     } catch (std::out_of_range& e) {
98494       {
98495         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98496       };
98497     } catch (std::exception& e) {
98498       {
98499         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98500       };
98501     } catch (Dali::DaliException e) {
98502       {
98503         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98504       };
98505     } catch (...) {
98506       {
98507         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98508       };
98509     }
98510   }
98511 }
98512
98513 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Connect(void * jarg1, void * jarg2)
98514 {
98515   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98516   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98517   {
98518     try {
98519       proxy->Connect(callback);
98520     } catch (std::out_of_range& e) {
98521       {
98522         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98523       };
98524     } catch (std::exception& e) {
98525       {
98526         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98527       };
98528     } catch (Dali::DaliException e) {
98529       {
98530         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98531       };
98532     } catch (...) {
98533       {
98534         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98535       };
98536     }
98537   }
98538 }
98539
98540
98541 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadSignal_Disconnect(void * jarg1, void * jarg2) {
98542   SignalConverter::WebViewPageLoadSignal* proxy = (SignalConverter::WebViewPageLoadSignal*) jarg1;
98543   SignalConverter::WebViewPageLoadSignal::CallbackType callback = (SignalConverter::WebViewPageLoadSignal::CallbackType) jarg2;
98544   {
98545     try {
98546       proxy->Disconnect(callback);
98547     } catch (std::out_of_range& e) {
98548       {
98549         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98550       };
98551     } catch (std::exception& e) {
98552       {
98553         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98554       };
98555     } catch (Dali::DaliException e) {
98556       {
98557         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98558       };
98559     } catch (...) {
98560       {
98561         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98562       };
98563     }
98564   }
98565 }
98566
98567 SWIGEXPORT void * SWIGSTDCALL CSharp_Dali_new_WebViewPageLoadErrorSignal_PageLoadError(void * jarg1) {
98568   Dali::Toolkit::WebView* webview = (Dali::Toolkit::WebView *) jarg1;
98569   SignalConverter::WebViewPageLoadErrorSignal* result = NULL;
98570   {
98571     try {
98572       result = new SignalConverter::WebViewPageLoadErrorSignal(&webview->PageLoadErrorSignal());
98573     } catch (std::out_of_range& e) {
98574       {
98575         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98576       };
98577     } catch (std::exception& e) {
98578       {
98579         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98580       };
98581     } catch (Dali::DaliException e) {
98582       {
98583         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98584       };
98585     } catch (...) {
98586       {
98587         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98588       };
98589     }
98590   }
98591   return (void*) result;
98592 }
98593
98594 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_delete_WebViewPageLoadErrorSignal(void * jarg1)
98595 {
98596   SignalConverter::WebViewPageLoadErrorSignal* object = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98597   {
98598     try {
98599       delete object;
98600     } catch (std::out_of_range& e) {
98601       {
98602         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98603       };
98604     } catch (std::exception& e) {
98605       {
98606         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98607       };
98608     } catch (Dali::DaliException e) {
98609       {
98610         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98611       };
98612     } catch (...) {
98613       {
98614         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98615       };
98616     }
98617   }
98618 }
98619
98620 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Connect(void * jarg1, void * jarg2)
98621 {
98622   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98623   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98624   {
98625     try {
98626       proxy->Connect(callback);
98627     } catch (std::out_of_range& e) {
98628       {
98629         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98630       };
98631     } catch (std::exception& e) {
98632       {
98633         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98634       };
98635     } catch (Dali::DaliException e) {
98636       {
98637         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98638       };
98639     } catch (...) {
98640       {
98641         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98642       };
98643     }
98644   }
98645 }
98646
98647
98648 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_WebViewPageLoadErrorSignal_Disconnect(void * jarg1, void * jarg2) {
98649   SignalConverter::WebViewPageLoadErrorSignal* proxy = (SignalConverter::WebViewPageLoadErrorSignal*) jarg1;
98650   SignalConverter::WebViewPageLoadErrorSignal::CallbackType callback = (SignalConverter::WebViewPageLoadErrorSignal::CallbackType) jarg2;
98651   {
98652     try {
98653       proxy->Disconnect(callback);
98654     } catch (std::out_of_range& e) {
98655       {
98656         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return ;
98657       };
98658     } catch (std::exception& e) {
98659       {
98660         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return ;
98661       };
98662     } catch (Dali::DaliException e) {
98663       {
98664         SWIG_CSharpException(SWIG_UnknownError, e.condition); return ;
98665       };
98666     } catch (...) {
98667       {
98668         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return ;
98669       };
98670     }
98671   }
98672 }
98673
98674 SWIGEXPORT char * SWIGSTDCALL CSharp_Dali_GetEnvironmentVariable(char * jarg1) {
98675   const char * result = EnvironmentVariable::GetEnvironmentVariable(jarg1);
98676   char * jresult = SWIG_csharp_string_callback((const char *)result);
98677   return jresult;
98678 }
98679
98680 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_SetEnvironmentVariable(char * jarg1, char * jarg2) {
98681   bool result = EnvironmentVariable::SetEnvironmentVariable(jarg1, jarg2);
98682   return result;
98683 }
98684
98685
98686 struct NativeImageSourcePtrHandle
98687 {
98688   NativeImageSourcePtr Ptr;
98689 };
98690
98691 SWIGEXPORT NativeImageInterface* SWIGSTDCALL CSharp_Dali_NativeImageSource_Upcast(void* jarg1)
98692 {
98693   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98694   return (NativeImageInterface*)(arg1);
98695 }
98696
98697 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New_Handle(unsigned int jarg1, unsigned int jarg2, int jarg3)
98698 {
98699   void* jresult;
98700   NativeImageSourcePtrHandle* handle = new NativeImageSourcePtrHandle();
98701   {
98702     try {
98703       handle->Ptr = ( NativeImageSource::New(jarg1, jarg2, (NativeImageSource::ColorDepth)jarg3) );
98704     }
98705     catch (std::out_of_range & e) {
98706       {
98707         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98708       };
98709     }
98710     catch (std::exception & e) {
98711       {
98712         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98713       };
98714     }
98715     catch (Dali::DaliException e) {
98716       {
98717         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98718       };
98719     }
98720     catch (...) {
98721       {
98722         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98723       };
98724     }
98725   }
98726   jresult = (void *)handle;
98727   return jresult;
98728 }
98729
98730 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_New(void* jarg1)
98731 {
98732   void* jresult;
98733   NativeImageSourcePtrHandle* handle = (NativeImageSourcePtrHandle*)jarg1;
98734   jresult = (void*)( handle->Ptr.Get() );
98735   return jresult;
98736 }
98737
98738 SWIGEXPORT void SWIGSTDCALL CSharp_Dali_NativeImageSource_Delete(void* jarg1) {
98739   NativeImageSourcePtrHandle* arg1 = (NativeImageSourcePtrHandle*)jarg1;
98740   {
98741     try {
98742       delete arg1;
98743     }
98744     catch (std::out_of_range & e) {
98745       {
98746         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return;
98747       };
98748     }
98749     catch (std::exception & e) {
98750       {
98751         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return;
98752       };
98753     }
98754     catch (Dali::DaliException e) {
98755       {
98756         SWIG_CSharpException(SWIG_UnknownError, e.condition); return;
98757       };
98758     }
98759     catch (...) {
98760       {
98761         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return;
98762       };
98763     }
98764   }
98765 }
98766
98767 SWIGEXPORT void* SWIGSTDCALL CSharp_Dali_NativeImageSource_AcquireBuffer(void* jarg1, int* jarg2, int* jarg3, int* jarg4)
98768 {
98769   void* jresult;
98770   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98771   uint16_t* arg2 = (uint16_t*)(jarg2);
98772   uint16_t* arg3 = (uint16_t*)(jarg3);
98773   uint16_t* arg4 = (uint16_t*)(jarg4);
98774   {
98775     try {
98776       jresult = (void *)Dali::DevelNativeImageSource::AcquireBuffer( *arg1, *arg2, *arg3, *arg4 );
98777     }
98778     catch (std::out_of_range & e) {
98779       {
98780         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98781       };
98782     }
98783     catch (std::exception & e) {
98784       {
98785         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98786       };
98787     }
98788     catch (Dali::DaliException e) {
98789       {
98790         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98791       };
98792     }
98793     catch (...) {
98794       {
98795         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98796       };
98797     }
98798   }
98799   return jresult;
98800 }
98801
98802 SWIGEXPORT bool SWIGSTDCALL CSharp_Dali_NativeImageSource_ReleaseBuffer(void* jarg1)
98803 {
98804   bool jresult;
98805   NativeImageSource* arg1 = (NativeImageSource*)jarg1;
98806
98807   {
98808     try {
98809       jresult = Dali::DevelNativeImageSource::ReleaseBuffer( *arg1 );
98810     }
98811     catch (std::out_of_range & e) {
98812       {
98813         SWIG_CSharpException(SWIG_IndexError, const_cast<char*>(e.what())); return 0;
98814       };
98815     }
98816     catch (std::exception & e) {
98817       {
98818         SWIG_CSharpException(SWIG_RuntimeError, const_cast<char*>(e.what())); return 0;
98819       };
98820     }
98821     catch (Dali::DaliException e) {
98822       {
98823         SWIG_CSharpException(SWIG_UnknownError, e.condition); return 0;
98824       };
98825     }
98826     catch (...) {
98827       {
98828         SWIG_CSharpException(SWIG_UnknownError, "unknown error"); return 0;
98829       };
98830     }
98831   }
98832   return jresult;
98833 }
98834
98835
98836 #ifdef __cplusplus
98837 }
98838 #endif
98839